octave-nkf: libinterp/dldfcn/__magick_read_

annotate libinterp/dldfcn/__magick_read__.cc @ 17118:c97a26408ee0

Implement PixelRegion option for imread(). * imread.m: document new option. * private/__imread__.m: parse new option and set defaults. * __magick_read__.cc (calculate region): new option to calculate the region to be read, shifts in memory required, and output image size. (read_indexed_images, read_images): implement reading of only specific regions of an image. (__magick_read__): get octave_scalar_map at start for simplicity.

author	Carnë Draug <carandraug@octave.org>
date	Wed, 31 Jul 2013 21:28:48 +0100
parents	59acfe9209dd
children	7066eec3431c

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
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	47 static std::map<std::string, octave_idx_type>
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	48 calculate_region (const octave_scalar_map& options)
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	49 {
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	50 std::map<std::string, octave_idx_type> region;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	51 const Cell pixel_region = options.getfield ("region").cell_value ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	52
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	53 // Subtract 1 to account for 0 indexing.
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	54 const Range rows = pixel_region (0).range_value ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	55 const Range cols = pixel_region (1).range_value ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	56 region["row_start"] = rows.base () -1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	57 region["col_start"] = cols.base () -1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	58 region["row_end"] = rows.limit () -1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	59 region["col_end"] = cols.limit () -1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	60
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	61 // Length of the area to load into the Image Pixel Cache
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	62 region["row_cache"] = region["row_end"] - region["row_start"] +1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	63 region["col_cache"] = region["col_end"] - region["col_start"] +1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	64
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	65 // How much we have to shift in the memory when doing the loops.
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	66 region["row_shift"] = region["col_cache"] * rows.inc ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	67 region["col_shift"] = region["col_cache"] * region["row_cache"] - cols.inc ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	68
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	69 // The actual height and width of the output image
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	70 region["row_out"] = floor ((region["row_end"] - region["row_start"]) / rows.inc ()) + 1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	71 region["col_out"] = floor ((region["col_end"] - region["col_start"]) / cols.inc ()) + 1;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	72
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	73 return region;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	74 }
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	75
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	76 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	77 static octave_value_list
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	78 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	79 const Array<octave_idx_type>& frameidx,
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	80 const octave_idx_type nargout,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	81 const octave_scalar_map& options)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	82 {
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	83 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	84
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	85 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	86
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	87 std::map<std::string, octave_idx_type> region = calculate_region (options);
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	88 const octave_idx_type nFrames = frameidx.length ();
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	89 const octave_idx_type nRows = region["row_out"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	90 const octave_idx_type nCols = region["col_out"];
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	91
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	92 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	93 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	94
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	95 const octave_idx_type row_start = region["row_start"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	96 const octave_idx_type col_start = region["col_start"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	97 const octave_idx_type row_shift = region["row_shift"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	98 const octave_idx_type col_shift = region["col_shift"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	99 const octave_idx_type row_cache = region["row_cache"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	100 const octave_idx_type col_cache = region["col_cache"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	101
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	102 // 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	103 // 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	104 // 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	105 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	106 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	107 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	108 imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	109 col_cache, row_cache);
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	110
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	111 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	112 = imvec[frameidx(frame)].getConstIndexes ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	113
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	114 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	115 {
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 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	117 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	118 img_fvec[idx++] = static_cast<P> (*pix);
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	119 pix += row_shift;
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	120 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	121 pix -= col_shift;
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	122 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	123 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	124 retval(0) = octave_value (img);
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 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 // 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	127 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	128 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	129 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	130 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	131
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	132 // 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	133 // 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	134 // 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	135
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	136 // 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	137 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	138 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	139 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	140 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	141 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	142 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	143 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	144 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	145 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	146 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	147 }
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	148
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	149 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	150 const octave_idx_type nPixels = alpha.numel ();
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	151
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	152 double* alpha_fvec = alpha.fortran_vec ();
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	153
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	154 idx = 0;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	155 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	156 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	157 // 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	158 // 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	159 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	160 idx++;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 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 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	163 }
10100 dd4d4b14b340 __magick_read__.cc: no need to explicitly call chop_trailing_singletons now John W. Eaton <jwe@octave.org> parents: 9575 diff changeset	164
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	165 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	166 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	167 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	168 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	169 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	170 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	171 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	172 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	173 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	174 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	175
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	176 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	177 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	178
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	179 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	180 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	181
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	182 // 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	183 // 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	184 // 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	185 // readability too much.
10193 1a4074e277fe undo unintended change to __magick_read__.cc John W. Eaton <jwe@octave.org> parents: 10191 diff changeset	186 template <class T>
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	187 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	188 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	189 const Array<octave_idx_type>& frameidx,
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	190 const octave_idx_type nargout,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	191 const octave_scalar_map& options)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	192 {
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	193 typedef typename T::element_type P;
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	194
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	195 octave_value_list retval (3, Matrix ());
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	196
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	197 std::map<std::string, octave_idx_type> region = calculate_region (options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	198 const octave_idx_type nFrames = frameidx.length ();
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	199 const octave_idx_type nRows = region["row_out"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	200 const octave_idx_type nCols = region["col_out"];
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	201 T img;
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	202
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	203 const octave_idx_type row_start = region["row_start"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	204 const octave_idx_type col_start = region["col_start"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	205 const octave_idx_type row_shift = region["row_shift"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	206 const octave_idx_type col_shift = region["col_shift"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	207 const octave_idx_type row_cache = region["row_cache"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	208 const octave_idx_type col_cache = region["col_cache"];
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	209
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	210 // 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	211 // 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	212 // 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	213 // 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	214 // 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	215 // 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	216 // 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	217 // 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	218 // 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	219 // See bug #39249).
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	220 // 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	221 // 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	222 // 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	223 // 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	224 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	225 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	226 ((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	227 ((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	228
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	229 // 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	230 // new ImageType BilevelMatteType
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	231 // 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	232 // 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	233 // 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	234 // 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	235 // 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	236 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	237 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	238 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	239 type = Magick::GrayscaleMatteType;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	240 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	241
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	242 // 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	243 // 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	244 if (nargout < 3)
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	245 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	246 switch (type)
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	247 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	248 case Magick::GrayscaleMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	249 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	250 type = Magick::GrayscaleType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	251 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	252 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	253 case Magick::PaletteMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	254 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	255 type = Magick::PaletteType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	256 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	257 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	258 case Magick::TrueColorMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	259 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	260 type = Magick::TrueColorType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	261 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	262 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	263 case Magick::ColorSeparationMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	264 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	265 type = Magick::ColorSeparationType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	266 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	267 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	268 default:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	269 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	270 // 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	271 // 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	272 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	273 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	274 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	275
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	276 switch (type)
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	277 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	278 case Magick::BilevelType: // Monochrome bi-level image
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	279 case Magick::GrayscaleType: // Grayscale image
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	280 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	281 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	282 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	283
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	284 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	285 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	286 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	287 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	288 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	289 col_cache, row_cache);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	290
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	291 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	292 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	293 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	294 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	295 img_fvec[idx++] = pix->red / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	296 pix += row_shift;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	297 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	298 pix -= col_shift;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	299 }
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	300 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	301 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	302 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	303
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	304 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	305 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	306 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	307 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	308 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	309 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	310
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	311 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	312 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	313 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	314 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	315 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	316 col_cache, row_cache);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	317
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	318 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	319 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	320 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	321 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	322 img_fvec[idx] = pix->red / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	323 a_fvec[idx] = pix->opacity / divisor;
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	324 pix += row_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	325 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	326 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	327 pix -= col_shift;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	328 }
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	329 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	330 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	331 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	332 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	333
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	334 case Magick::PaletteType: // Indexed color (palette) image
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	335 case Magick::TrueColorType: // Truecolor image
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	336 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	337 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	338 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	339
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	340 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	341 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	342 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	343 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	344 col_cache, row_cache);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	345
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	346 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	347 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	348 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	349 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	350 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	351
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	352 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	353 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	354 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	355 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	356 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	357 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	358 bbuf[idx] = pix->blue / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	359 pix += row_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	360 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	361 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	362 pix -= col_shift;
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 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	365 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	366 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	367
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	368 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	369 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	370 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	371 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	372 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	373 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	374 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	375
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	376 // 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	377 // 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	378 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	379 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	380 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	381 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	382 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	383 col_cache, row_cache);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	384
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	385 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	386 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	387 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	388 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	389 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	390
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	391 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	392 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	393 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	394 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	395 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	396 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	397 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	398 a_fvec[a_idx] = pix->opacity / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	399 pix += row_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	400 idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	401 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	402 pix -= col_shift;
17110 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 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	405 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	406 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	407 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	408
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	409 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	410 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	411 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	412 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	413
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	414 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	415 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	416 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	417 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	418 col_cache, row_cache);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	419
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	420 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	421 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	422 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	423 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	424 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	425 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	426
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	427 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	428 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	429 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	430 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	431 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	432 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	433 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	434 kbuf[idx] = pix->opacity / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	435 pix += row_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	436 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	437 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	438 pix -= col_shift;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	439 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	440 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	441 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	442 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	443
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	444 // 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	445 case Magick::ColorSeparationMatteType:
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	446 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	447 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	448 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	449 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	450 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	451
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	452 // 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	453 // 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	454 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	455 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	456 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	457 const Magick::PixelPacket *pix
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	458 = imvec[frameidx(frame)].getConstPixels (col_start, row_start,
c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	459 col_cache, row_cache);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	460 // 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	461 // 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	462 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	463 = imvec[frameidx(frame)].getConstIndexes ();
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	464
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	465 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	466 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	467 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	468 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	469 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	470 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	471
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	472 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	473 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	474 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	475 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	476 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	477 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	478 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	479 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	480 a_fvec[a_idx] = *apix / divisor;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	481 pix += row_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	482 idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	483 a_idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	484 }
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	485 pix -= col_shift;
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	486 }
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	487 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	488 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	489 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	490 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	491
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	492 default:
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	493 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	494 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	495 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	496
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	497 retval(0) = img;
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	498 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	499 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	500
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	501
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	502 void static
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	503 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	504 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	505 try
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	506 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	507 // Read a file into vector of image objects
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	508 Magick::readImages (&imvec, filename);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	509 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	510 catch (Magick::Warning& w)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	511 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	512 warning ("Magick++ warning: %s", w.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	513 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	514 catch (Magick::ErrorCoder& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	515 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	516 // FIXME: there's a WarningCoder and ErrorCoder. Shouldn't this
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	517 // exception cause an error?
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	518 warning ("Magick++ coder error: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	519 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	520 catch (Magick::Exception& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	521 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	522 error ("Magick++ exception: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	523 error_state = 1;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	524 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	525 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	526
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	527
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	528 static void
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	529 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	530 {
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	531 static bool initialized = false;
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	532
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	533 if (! initialized)
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	534 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	535 // Save locale as GraphicsMagick might change this (fixed in
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	536 // 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	537 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	538 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	539
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	540 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	541 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	542
10739 d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	543 // 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	544 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	545
11036 169f59f626d3 Add check for QuantumDepth at initialization of Magick and an associated warning John Swensen <jpswensen@gmail.com>* parents: 11035 diff changeset	546 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	547 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	548 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	549 MagickPackageName, QuantumDepth);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	550 }
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	551 initialized = true;
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	552 }
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	553 }
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	554 #endif
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	555
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	556 DEFUN_DLD (__magick_read__, args, nargout,
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	557 "-- texinfo --\n\
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	558 @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	559 Read image with GraphicsMagick or ImageMagick.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	560 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	561 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	562 use @code{imread}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	563 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	564 @seealso{imfinfo, imformats, imread, imwrite}\n\
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	565 @end deftypefn")
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	566 {
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	567 octave_value_list output;
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	568
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	569 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	570 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	571 #else
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	572
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	573 maybe_initialize_magick ();
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	574
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	575 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	576 {
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	577 print_usage ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	578 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	579 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	580
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	581 const octave_scalar_map options = args(1).scalar_map_value ();
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	582 if (error_state)
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	583 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	584 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	585 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	586
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	587 std::vector<Magick::Image> imvec;
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	588 read_file (args(0).string_value (), imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	589 if (error_state)
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	590 {
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	591 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	592 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	593
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	594 // 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	595 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	596 Array<octave_idx_type> frameidx;
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	597 const octave_value indexes = options.getfield ("index");
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	598 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	599 {
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	600 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	601 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	602 {
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	603 frameidx(i) = i;
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	604 }
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	605 }
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	606 else
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	607 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	608 frameidx = indexes.int_vector_value ();
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	609 if (error_state)
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	610 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	611 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	612 }
16989 7a69ab84b8c9 __magick_write__: confirm file exists before reading to append. Carnë Draug <carandraug@octave.org> parents: 16988 diff changeset	613 // 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	614 // 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	615 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	616 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	617 {
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	618 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	619 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	620 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	621 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	622 return output;
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	623 }
8053 89a512e8ec43 Replace leading tabs with spaces. scofield@scofield parents: 7974 diff changeset	624 }
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	625 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	626
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	627 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	628 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	629
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	630 // Magick::ClassType
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	631 // PseudoClass:
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	632 // 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	633 // DirectClass:
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	634 // 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	635
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	636 // 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	637 // 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	638 // 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	639 // 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	640 // 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	641 // 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	642 // 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	643 // 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	644 // 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	645 // for that.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	646
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	647 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	648 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	649 if (depth <= 1)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	650 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	651 output = read_indexed_images <boolNDArray> (imvec, frameidx, nargout, options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	652 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	653 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	654 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	655 output = read_indexed_images <uint8NDArray> (imvec, frameidx, nargout, options);
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	656 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	657 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	658 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	659 output = read_indexed_images <uint16NDArray> (imvec, frameidx, nargout, options);
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	660 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	661 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	662 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	663 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	664 return output;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	665 }
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	666 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	667
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	668 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	669 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	670 if (depth <= 1)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	671 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	672 output = read_images<boolNDArray> (imvec, frameidx, nargout, options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	673 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	674 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	675 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	676 output = read_images<uint8NDArray> (imvec, frameidx, nargout, options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	677 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	678 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	679 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	680 output = read_images<uint16NDArray> (imvec, frameidx, nargout, options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	681 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	682 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	683 {
17118 c97a26408ee0 Implement PixelRegion option for imread(). Carnë Draug <carandraug@octave.org> parents: 17116 diff changeset	684 output = read_images<FloatNDArray> (imvec, frameidx, nargout, options);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	685 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	686 else
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	687 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	688 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	689 depth);
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	690 }
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	691 }
7937 6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	692
6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	693 #endif
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	694 return output;
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	695 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	696
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	697 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	698 ## 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	699 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	700 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	701
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	702 #ifdef HAVE_MAGICK
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	703
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	704 static void
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	705 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	706 {
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	707 unsigned int nframes = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	708 boolNDArray m = img.bool_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	709
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	710 dim_vector dsizes = m.dims ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	711 if (dsizes.length () == 4)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	712 nframes = dsizes(3);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	713
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11553 diff changeset	714 Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	715
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	716 octave_idx_type rows = m.rows ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	717 octave_idx_type columns = m.columns ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	718
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	719 for (unsigned int ii = 0; ii < nframes; ii++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	720 {
14854 5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14846 diff changeset	721 Magick::Image im (Magick::Geometry (columns, rows), "black");
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	722 im.classType (Magick::DirectClass);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	723 im.depth (1);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	724
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	725 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	726 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	727 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	728
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	729 for (int x = 0; x < rows; x++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	730 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	731 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	732 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	733 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	734 idx(3) = 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
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	737 idx(0) = x;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	738
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	739 if (m(idx))
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	740 im.pixelColor (y, x, "white");
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	741 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	742 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	743
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	744 im.quantizeColorSpace (Magick::GRAYColorspace);
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	745 im.quantizeColors (2);
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	746 im.quantize ();
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	747
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	748 imvec.push_back (im);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	749 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	750 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	751
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	752 template <class T>
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	753 static void
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	754 encode_uint_image (std::vector<Magick::Image>& imvec,
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	755 const octave_value& img,
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	756 const bool has_map)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	757 {
8520 715f6cd8d5e7 __magick_read__.cc (encode_uint_image): initialize bitdepth Soren Hauberg <hauberg@gmail.com> parents: 8165 diff changeset	758 unsigned int bitdepth = 0;
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	759 T m;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	760
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	761 if (img.is_uint8_type ())
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	762 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	763 bitdepth = 8;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	764 m = img.uint8_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	765 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	766 else if (img.is_uint16_type ())
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	767 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	768 bitdepth = 16;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	769 m = img.uint16_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	770 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	771 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	772 error ("__magick_write__: invalid image class");
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	773
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	774 const dim_vector dsizes = m.dims ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	775 unsigned int nframes = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	776 if (dsizes.length () == 4)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	777 nframes = dsizes(3);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	778
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	779 const bool is_color = ((dsizes.length () > 2) && (dsizes(2) > 2));
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	780 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	781
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11553 diff changeset	782 Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	783 octave_idx_type rows = m.rows ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	784 octave_idx_type columns = m.columns ();
8090 3cc1ca1b1576 MSVC compilation fix Michael Goffioul parents: 8054 diff changeset	785
13020 58d704d3283c Fix ambigous call to int pow (int, unsigned int&) Carlo de Falco <kingcrimson@tiscali.it> parents: 11590 diff changeset	786 unsigned int div_factor = (1 << bitdepth) - 1;
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	787
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	788 for (unsigned int ii = 0; ii < nframes; ii++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	789 {
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	790 Magick::Image im (Magick::Geometry (columns, rows), "black");
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	791
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	792 im.depth (bitdepth);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	793
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	794 if (has_map)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	795 im.classType (Magick::PseudoClass);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	796 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	797 im.classType (Magick::DirectClass);
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 if (is_color)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	800 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	801 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	802 im.type (Magick::TrueColorMatteType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	803 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	804 im.type (Magick::TrueColorType);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	805
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	806 Magick::ColorRGB c;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	807
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	808 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	809 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	810 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	811
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	812 for (int x = 0; x < rows; x++)
8054 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 idx(0) = x;
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 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	817 idx(3) = ii;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	818
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	819 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	820 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	821
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	822 idx(2) = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	823 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	824
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	825 idx(2) = 2;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	826 c.blue (static_cast<double>(m(idx)) / div_factor);
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 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	829 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	830 idx(2) = 3;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	831 c.alpha (static_cast<double>(m(idx)) / div_factor);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	832 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	833
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	834 im.pixelColor (y, x, c);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	835 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	836 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	837 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	838 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	839 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	840 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	841 im.type (Magick::GrayscaleMatteType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	842 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	843 im.type (Magick::GrayscaleType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	844
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	845 Magick::ColorGray c;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	846
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	847 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	848 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	849 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	850
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	851 for (int x=0; x < rows; x++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	852 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	853 idx(0) = x;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	854
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	855 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	856 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	857 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	858 idx(3) = ii;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	859 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	860
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	861 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	862 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	863 idx(2) = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	864 c.alpha (static_cast<double>(m(idx)) / div_factor);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	865 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	866 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	867
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	868 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	869
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	870 im.pixelColor (y, x, c);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	871 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	872 }
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	873
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	874 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	875 im.quantizeColors (1 << bitdepth);
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	876 im.quantize ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	877 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	878
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	879 imvec.push_back (im);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	880 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	881 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	882
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	883 // FIXME: this will be needed to write indexed images
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	884 //static void
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	885 //encode_map (std::vector<Magick::Image>& imvec, const NDArray& cmap)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	886 //{
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	887 // unsigned int mapsize = cmap.dim1 ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	888
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	889 // for (size_t fnum = 0; fnum < imvec.size (); fnum++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	890 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	891 // imvec[fnum].colorMapSize (mapsize);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	892 // imvec[fnum].type (Magick::PaletteType);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	893 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	894
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	895 // for (unsigned int ii = 0; ii < mapsize; ii++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	896 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	897 // 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	898
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	899 // // FIXME -- is this case needed?
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	900 // if (cmap.dim2 () == 4)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	901 // c.alpha (cmap(ii,3));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	902
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	903 // try
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	904 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	905 // for_each (imvec.begin (), imvec.end (),
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	906 // Magick::colorMapImage (ii, c));
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	907 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	908 // catch (Magick::Warning& w)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	909 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	910 // warning ("Magick++ warning: %s", w.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	911 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	912 // catch (Magick::ErrorCoder& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	913 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	914 // warning ("Magick++ coder error: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	915 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	916 // catch (Magick::Exception& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	917 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	918 // error ("Magick++ exception: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	919 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	920 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	921 //}
9275 86f475d5e7d1 imwrite.m: convert indexed images to RGB before calling __magick_write__ John W. Eaton <jwe@octave.org> parents: 9274 diff changeset	922
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	923 void static
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	924 write_file (const std::string filename,
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	925 const std::string ext,
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	926 std::vector<Magick::Image>& imvec)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	927 {
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	928 try
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	929 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	930 Magick::writeImages (imvec.begin (), imvec.end (), ext + ":" + filename);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	931 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	932 catch (Magick::Warning& w)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	933 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	934 warning ("Magick++ warning: %s", w.what ());
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	935 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	936 catch (Magick::ErrorCoder& e)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	937 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	938 warning ("Magick++ coder error: %s", e.what ());
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	939 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	940 catch (Magick::Exception& e)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	941 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	942 error ("Magick++ exception: %s", e.what ());
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	943 error_state = 1;
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	944 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	945 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	946
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	947 #endif
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	948
9436 5302df15ad76 __magick_read__.cc: undo unintended change John W. Eaton <jwe@octave.org> parents: 9434 diff changeset	949 DEFUN_DLD (__magick_write__, args, ,
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	950 "-- texinfo --\n\
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	951 @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	952 Write image with GraphicsMagick or ImageMagick.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	953 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	954 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	955 use @code{imwrite}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	956 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	957 @seealso{imfinfo, imformats, imread, imwrite}\n\
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	958 @end deftypefn")
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	959 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	960 octave_value_list retval;
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	961
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	962 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	963 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	964 #else
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	965
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	966 maybe_initialize_magick ();
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	967
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	968 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	969 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	970 print_usage ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	971 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	972 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	973 const std::string filename = args(0).string_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	974 const std::string ext = args(1).string_value ();
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	975
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	976 const octave_map options = args(4).map_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	977 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	978 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	979 error ("__magick_write__: OPTIONS must be a struct");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	980 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	981
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	982 const octave_value img = args(2);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	983 const Matrix cmap = args(3).matrix_value ();
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 error ("__magick_write__: invalid IMG or MAP");
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 const bool is_indexed = ! cmap.is_empty ();
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 // Create vector with the images to write
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	991 std::vector<Magick::Image> imvec;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	992 if (img.is_bool_type ())
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	993 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	994 encode_bool_image (imvec, img);
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 else if (img.is_uint8_type ())
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 encode_uint_image<uint8NDArray> (imvec, img, is_indexed);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	999 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1000 else if (img.is_uint16_type ())
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1001 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1002 encode_uint_image<uint16NDArray> (imvec, img, is_indexed);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1003 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1004 else
16988 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 error ("__magick_write__: image type not supported");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1007 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1008 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1009 const int nframes = imvec.size ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1010
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1011 // Add colormap to image
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1012 if (is_indexed)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1013 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1014 // 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	1015 // conversion in case of indexed images.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1016 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	1017 // encode_map (imvec, cmap);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1018 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1019 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1020
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1021 // Set quality.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1022 // 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	1023 const unsigned int quality = options.getfield ("quality")(0).int_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1024 for (int i = 0; i < nframes; i++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1025 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1026 imvec[i].quality (quality);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1027 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1028
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1029 // Finally, save the file.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1030 // 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	1031 // 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	1032 // read at all.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1033 const std::string writemode = options.getfield ("writemode")(0).string_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1034 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	1035 if (writemode == "append" && file_stat (filename).exists ())
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1036 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1037 read_file (filename, ini_imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1038 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1039 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1040 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1041 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1042 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1043
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1044 if (ini_imvec.size () > 0)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1045 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1046 ini_imvec.insert (ini_imvec.end (), imvec.begin (), imvec.end ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1047 write_file (filename, ext, ini_imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1048 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1049 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1050 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1051 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1052 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1053 else
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1054 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1055 write_file (filename, ext, imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1056 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1057 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1058 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1059 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1060 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1061
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1062 #endif
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1063 return retval;
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1064 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1065
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1066 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1067 ## 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	1068 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1069 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1070
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	1071 #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	1072
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1073 template<class T>
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1074 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1075 magick_to_octave_value (const T magick)
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 return octave_value (magick);
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1078 }
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 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1081 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	1082 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1083 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1084 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1085 case Magick::LSBEndian:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1086 return octave_value ("little-endian");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1087
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1088 case Magick::MSBEndian:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1089 return octave_value ("big-endian");
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 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1092 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1093 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1094 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1095
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1096 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1097 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	1098 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1099 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1100 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1101 case Magick::PixelsPerInchResolution:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1102 return octave_value ("pixels per inch");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1103
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1104 case Magick::PixelsPerCentimeterResolution:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1105 return octave_value ("pixels per centimeter");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1106
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1107 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1108 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1109 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1110 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1111
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1112 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1113 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	1114 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1115 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1116 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1117 case Magick::BilevelType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1118 case Magick::GrayscaleType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1119 case Magick::GrayscaleMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1120 return octave_value ("grayscale");
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 case Magick::PaletteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1123 case Magick::PaletteMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1124 return octave_value ("indexed");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1125
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1126 case Magick::TrueColorType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1127 case Magick::TrueColorMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1128 case Magick::ColorSeparationType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1129 return octave_value ("truecolor");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1130
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1131 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1132 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1133 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1134 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1135
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1136 // 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	1137 // 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	1138 #define GET_PARAM(NAME, OUTNAME) \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1139 try \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1140 { \
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1141 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	1142 } \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1143 catch (Magick::Warning& w) \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1144 { \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1145 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1146
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	1147 #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	1148
9436 5302df15ad76 __magick_read__.cc: undo unintended change John W. Eaton <jwe@octave.org> parents: 9434 diff changeset	1149 DEFUN_DLD (__magick_finfo__, args, ,
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1150 "-- 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	1151 @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	1152 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	1153 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1154 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	1155 use @code{imfinfo}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1156 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1157 @seealso{imfinfo, imformats, imread, imwrite}\n\
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1158 @end deftypefn")
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1159 {
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1160 octave_value retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1161
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1162 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1163 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	1164 #else
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1165
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1166 maybe_initialize_magick ();
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1167
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1168 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	1169 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1170 print_usage ();
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1171 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1172 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1173
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1174 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	1175
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1176 try
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1177 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1178 // Read the file.
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1179 std::vector<Magick::Image> imvec;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1180 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	1181 int nframes = imvec.size ();
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1182
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1183 // 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	1184
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1185 static const char *fields[] =
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1186 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1187 "Filename",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1188 "FileModDate",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1189 "FileSize",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1190 "Height",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1191 "Width",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1192 "BitDepth",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1193 "Format",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1194 "LongFormat",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1195 "XResolution",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1196 "YResolution",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1197 "TotalColors",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1198 "TileName",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1199 "AnimationDelay",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1200 "AnimationIterations",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1201 "ByteOrder",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1202 "Gamma",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1203 "Matte",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1204 "ModulusDepth",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1205 "Quality",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1206 "QuantizeColors",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1207 "ResolutionUnits",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1208 "ColorType",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1209 "View",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1210 0
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1211 };
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1212
16871 5e30b1c950b8 Replace uses of Octave_map with octave_map or octave_scalar_map. Rik <rik@octave.org> parents: 16543 diff changeset	1213 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	1214
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1215 file_stat fs (filename);
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1216
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1217 std::string filetime;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1218
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1219 if (fs)
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1220 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1221 octave_localtime mtime = fs.mtime ();
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1222
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1223 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	1224 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1225 else
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1226 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1227 std::string msg = fs.error ();
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1228
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14173 diff changeset	1229 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	1230 filename.c_str (), msg.c_str ());
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1231
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1232 return retval;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1233 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1234
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1235 // 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	1236 // 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	1237 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	1238 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1239 Magick::Image im = imvec[frame];
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1240
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1241 // Add file name and timestamp.
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1242 info.contents ("Filename")(frame,0) = filename;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1243 info.contents ("FileModDate")(frame,0) = filetime;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1244
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1245 // 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	1246 GET_PARAM (fileSize, "FileSize")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1247 GET_PARAM (rows, "Height")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1248 GET_PARAM (columns, "Width")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1249 GET_PARAM (depth, "BitDepth")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1250 GET_PARAM (magick, "Format")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1251 GET_PARAM (format, "LongFormat")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1252 GET_PARAM (xResolution, "XResolution")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1253 GET_PARAM (yResolution, "YResolution")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1254 GET_PARAM (totalColors, "TotalColors")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1255 GET_PARAM (tileName, "TileName")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1256 GET_PARAM (animationDelay, "AnimationDelay")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1257 GET_PARAM (animationIterations, "AnimationIterations")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1258 GET_PARAM (endian, "ByteOrder")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1259 GET_PARAM (gamma, "Gamma")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1260 GET_PARAM (matte, "Matte")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1261 GET_PARAM (modulusDepth, "ModulusDepth")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1262 GET_PARAM (quality, "Quality")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1263 GET_PARAM (quantizeColors, "QuantizeColors")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1264 GET_PARAM (resolutionUnits, "ResolutionUnits")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1265 GET_PARAM (type, "ColorType")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1266 GET_PARAM (view, "View")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1267 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1268
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1269 retval = octave_value (info);
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1270 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1271 catch (Magick::Warning& w)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1272 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1273 warning ("Magick++ warning: %s", w.what ());
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1274 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1275 catch (Magick::ErrorCoder& e)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1276 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1277 warning ("Magick++ coder error: %s", e.what ());
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1278 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1279 catch (Magick::Exception& e)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1280 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1281 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	1282 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1283 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1284 #endif
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1285 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1286 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1287
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1288 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1289 ## 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	1290 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1291 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1292
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1293 #undef GET_PARAM
11035 8a6b7947f618 Added support for checking supported image types at runtime. John Swensen <jpswensen@gmail.com> parents: 11034 diff changeset	1294
16901 861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1295 DEFUN_DLD (__magick_formats__, args, ,
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1296 "-- texinfo --\n\
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1297 @deftypefn {Loadable Function} {} __magick_imformats__ (@var{formats})\n\
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1298 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	1299 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1300 @seealso{imfinfo, imformats, imread, imwrite}\n\
16901 861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1301 @end deftypefn")
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1302 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1303 octave_value retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1304 #ifndef HAVE_MAGICK
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1305 gripe_disabled_feature ("imformats", "Image IO");
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1306 #else
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1307 if (args.length () != 1 \|\| ! args (0).is_map ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1308 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1309 print_usage ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1310 return retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1311 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1312 octave_map formats = args(0).map_value ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1313
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1314 maybe_initialize_magick ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1315 for (octave_idx_type idx = 0; idx < formats.numel (); idx++)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1316 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1317 try
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1318 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1319 octave_scalar_map fmt = formats.checkelem (idx);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1320 Magick::CoderInfo coder (fmt.getfield ("coder").string_value ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1321
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1322 fmt.setfield ("description", octave_value (coder.description ()));
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1323 fmt.setfield ("multipage", coder.isMultiFrame () ? true : false);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1324 // 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	1325 // read or write them, them set it to an empty value
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1326 if (! coder.isReadable ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1327 fmt.setfield ("read", Matrix ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1328 if (! coder.isWritable ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1329 fmt.setfield ("write", Matrix ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1330 formats.fast_elem_insert (idx, fmt);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1331 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1332 catch (Magick::Exception& e)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1333 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1334 // Exception here are missing formats. So we remove the format
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1335 // from the structure and reduce idx.
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1336 formats.delete_elements (idx);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1337 idx--;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1338 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1339 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1340 retval = formats;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1341 #endif
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1342 return retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1343 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1344
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1345 /*
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1346 ## No test needed for internal helper function.
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1347 %!assert (1)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1348 */

Mercurial > hg > octave-nkf

annotate libinterp/dldfcn/__magick_read__.cc @ 17118:c97a26408ee0