Mercurial > octave-libtiff
view scripts/io/Tiff.m @ 31171:8bf3fa6b6977
Tiff: added readRGBAStrip and readRGBATile methods
* __tiff__.cc: added internal functions for reading strips and tiles
using LibTIFF's RGBA interface.
* Tiff.m: added readRGBAStrip and readRGBATile methods to the Tiff class
and added unit tests for the ne methods.
author | magedrifaat <magedrifaat@gmail.com> |
---|---|
date | Sun, 14 Aug 2022 02:40:03 +0200 |
parents | 72a159bc5a4c |
children | 3f5f1404af8a |
line wrap: on
line source
## PKG_ADD: __tiff_set_errors_enabled__ (false); classdef Tiff < handle properties (Constant = true) TagID = struct ( "SubFileType", 254, "ImageWidth", 256, "ImageLength", 257, "BitsPerSample", 258, "Compression", 259, "Photometric", 262, "Thresholding", 263, "FillOrder", 266, "DocumentName", 269, "ImageDescription", 270, "Make", 271, "Model", 272, "StripOffsets", 273, "Orientation", 274, "SamplesPerPixel", 277, "RowsPerStrip", 278, "StripByteCounts", 279, "MinSampleValue", 280, "MaxSampleValue", 281, "XResolution", 282, "YResolution", 283, "PlanarConfiguration", 284, "PageName", 285, "XPosition", 286, "YPosition", 287, "GrayResponseUnit", 290, 'GrayResponseCurve', 291, "Group3Options", 292, "Group4Options", 293, "ResolutionUnit", 296, "PageNumber", 297, "TransferFunction", 301, "Software", 305, "DateTime", 306, "Artist", 315, "HostComputer", 316, "WhitePoint", 318, "PrimaryChromaticities", 319, "ColorMap", 320, "HalfToneHints", 321, "TileWidth", 322, "TileLength", 323, "TileOffsets", 324, "TileByteCounts", 325, "SubIFD", 330, "InkSet", 332, "InkNames", 333, "NumberOfInks", 334, "DotRange", 336, "TargetPrinter", 337, "ExtraSamples", 338, "SampleFormat", 339, "SMinSampleValue", 340, "SMaxSampleValue", 341, "YCbCrCoefficients", 529, "YCbCrSubSampling", 530, "YCbCrPositioning", 531, "ReferenceBlackWhite", 532, "XMP", 700, "ImageDepth", 32997, "Copyright", 33432, "RichTIFFIPTC", 33723, "Photoshop", 34377, "ICCProfile", 34675, "SToNits", 37439, "JPEGQuality", 65537, "JPEGColorMode", 65538, "ZipQuality", 65557, "SGILogDataFmt", 65560 ); Compression = struct ( "None", 1, "CCITTRLE", 2, "CCITTFax3", 3, "CCITTFax4", 4, "LZW", 5, "OJPEG", 6, "JPEG", 7, "AdobeDeflate", 8, "Next", 32766, "CCITTRLEW", 32771, "PackBits", 32773, "Thunderscan", 32809, "IT8CTPad", 32895, "IT8LW", 32896, "IT8MP", 32897, "IT8BL", 32898, "PixarFilm", 32908, "PixarLog", 32909, "Deflate", 32946, "DCS", 32947, "JBIG", 34661, "SGILog", 34676, "SGILog24", 34677, "JPEG2000", 34712, # Not defined in LibTIFF, only in matlab # TODO(maged): test these compression methods "JPEG2000_SVS_YCbCr", 33003, "JPEG2000_SVS_RGB", 33005 ); ExtraSamples = struct ( "Unspecified", 0, "AssociatedAlpha", 1, "UnassociatedAlpha", 2 ); Group3Options = struct ( "Encoding2D", 1, "Uncompressed", 2, "FillBits", 4 ); InkSet = struct ( "CMYK", 1, "MultiInk", 2 ); JPEGColorMode = struct ( "Raw", 0, "RGB", 1 ); Orientation = struct ( "TopLeft", 1, "TopRight", 2, "BottomRight", 3, "BottomLeft", 4, "LeftTop", 5, "RightTop", 6, "RightBottom", 7, "LeftBottom", 8 ); Photometric = struct ( "MinIsWhite", 0, "MinIsBlack", 1, "RGB", 2, "Palette", 3, "Mask", 4, "Separated", 5, "YCbCr", 6, "CIELab", 8, "ICCLab", 9, "ITULab", 10, "LogL", 32844, "LogLUV", 32845, "CFA", 32803, "LinearRaw", 34892 ); PlanarConfiguration = struct ( "Chunky", 1, "Separate", 2 ); ResolutionUnit = struct ( "None", 1, "Inch", 2, "Centimeter", 3 ); SampleFormat = struct ( "UInt", 1, "Int", 2, "IEEEFP", 3 ); SGILogDataFmt = struct ( "Float", 0, "Bits8", 3 ); SubFileType = struct ( "Default", 0, "ReducedImage", 1, "Page", 2, "Mask", 4 ); Thresholding = struct ( "BiLevel", 1, "HalfTone", 2, "ErrorDiffuse", 3 ); YCbCrPositioning = struct ( "Centered", 1, "Cosited", 2 ); endproperties properties (Access = private) tiff_handle; closed=false; endproperties methods function t = Tiff (filename, mode="r") if (nargin == 0 || nargin > 2) % print_usage(); error("Usage: Tiff(filename[, mode])"); endif t.tiff_handle = __open_tiff__ (filename, mode); endfunction function close (t) if (! t.closed) __close_tiff__ (t.tiff_handle); t.closed = true; endif endfunction function tag = getTag (t, tag_name) if (t.closed) error ("Image file was closed"); endif tag = __tiff_get_tag__ (t.tiff_handle, tag_name); endfunction function setTag (t, varargin) if (t.closed) error ("Image file was closed"); endif __tiff_set_tag__ (t.tiff_handle, varargin{:}); endfunction function argout = read (t) if (t.closed) error ("Image file was closed"); endif argout = __tiff_read__ (t.tiff_handle); endfunction function stripData = readEncodedStrip (t, stripNumber) if (t.closed) error ("Image file was closed"); endif stripData = __tiff_read_encoded_strip__ (t.tiff_handle, stripNumber); endfunction function tileData = readEncodedTile (t, tileNumber) if (t.closed) error ("Image file was closed"); endif tileData = __tiff_read_encoded_tile__ (t.tiff_handle, tileNumber); endfunction function [RGB, alpha] = readRGBAImage (t) if (t.closed) error ("Image file was closed"); endif [RGB, alpha] = __tiff_read_rgba_image__ (t.tiff_handle); endfunction function [RGB, alpha] = readRGBAStrip (t, row) if (t.closed) error ("Image file was closed"); endif [RGB, alpha] = __tiff_read_rgba_strip__ (t.tiff_handle, row); endfunction function [RGB, alpha] = readRGBATile (t, row, col) if (t.closed) error ("Image file was closed"); endif [RGB, alpha] = __tiff_read_rgba_tile__ (t.tiff_handle, row, col); endfunction function write (t, imageData) if (t.closed) error ("Image file was closed"); endif __tiff_write__ (t.tiff_handle, imageData); endfunction function writeEncodedStrip (t, stripNumber, imageData) if (t.closed) error ("Image file was closed"); endif __tiff_write_encoded_strip__ (t.tiff_handle, stripNumber, imageData); endfunction function writeEncodedTile (t, tileNumber, imageData) if (t.closed) error ("Image file was closed"); endif __tiff_write_encoded_tile__ (t.tiff_handle, tileNumber, imageData); endfunction function tf = isTiled (t) if (t.closed) error ("Image file was closed"); endif tf = __tiff_is_tiled__ (t.tiff_handle); endfunction function numStrips = numberOfStrips (t) if (t.closed) error ("Image file was closed"); endif numStrips = __tiff_number_of_strips__ (t.tiff_handle); endfunction function numTiles = numberOfTiles (t) if (t.closed) error ("Image file was closed"); endif numTiles = __tiff_number_of_tiles__ (t.tiff_handle); endfunction function stripNumber = computeStrip (t, varargin) if (t.closed) error ("Image file was closed"); endif stripNumber = __tiff_compute_strip__ (t.tiff_handle, varargin{:}); endfunction function tileNumber = computeTile (t, varargin) if (t.closed) error ("Image file was closed"); endif tileNumber = __tiff_compute_tile__ (t.tiff_handle, varargin{:}); endfunction % TODO(maged): add documentation and make print_usage work endmethods methods (Static = true) function versionString = getVersion() versionString = __tiff_version__ (); endfunction function setLibTIFFErrorsEnabled(state) __tiff_set_errors_enabled__ (state); endfunction endmethods endclassdef %!function file_wrapper (fn) %! filename = [tempname() ".tif"]; %! unwind_protect %! fn (filename); %! unwind_protect_cleanup %! unlink (filename); %! end_unwind_protect %!endfunction %!function verify_data (filename, data, ex_size) %! img = Tiff (filename, "r"); %! data2 = img.read (); %! assert (size (data2), ex_size); %! assert (data2, resize (data, size (data2))); %! img.close (); %!endfunction ## test setTag and getTag for scalar tags %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, "ImageWidth", 2); %! val = getTag (img, "ImageWidth"); %! assert (val, 2); %! assert (class (val), "double"); %! endfunction %! file_wrapper (@test_fn); ## test failure setTag and getTag unknown tag %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! fail ("getTag (img, \"ImageWidt\")", "Tiff tag not found"); %! fail ("getTag (img, 999999)", "Tiff tag not found"); %! fail ("setTag (img, \"ImageWidt\", 2)", "Tiff tag not found"); %! fail ("setTag (img, 999999, 2)", "Tiff tag not found"); %! endfunction %! file_wrapper (@test_fn); ## test setTag structure input %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 2, "ImageWidth", 2)); %! assert (getTag (img, "ImageLength"), 2); %! assert (getTag (img, "ImageWidth"), 2); %! endfunction %! file_wrapper (@test_fn); ## test failure setTag structure unknown tag %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, "ImageLength", 1); %! setTag (img, "ImageWidth", 1); %! fail ("setTag (img, struct (\"ImageLength\", 2, \"a\", 1, \"ImageWidth\", 2))", %! "Tag a not found"); %! assert (getTag (img, "ImageLength"), 2); %! assert (getTag (img, "ImageWidth"), 1); %! endfunction %! file_wrapper (@test_fn); ## test setTag array field %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, "YCbCrCoefficients", [1.5, 2.5, 3.5]); %! data = getTag (img, "YCbCrCoefficients"); %! assert (data, [1.5, 2.5, 3.5]); %! endfunction %! file_wrapper (@test_fn); ## test setTag special field %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, "BitsPerSample", 8); %! cmap = reshape (1:768, [256, 3]) / 1024.0; %! setTag (img, "ColorMap", cmap); %! assert (getTag (img, "ColorMap"), cmap, 1e-5); %! endfunction %! file_wrapper (@test_fn); ## test failure invalid open mode/ invalid filename %!testif HAVE_TIFF %! fail ("Tiff (\"test.tif\", \"rh\")", %! "Invalid mode for openning Tiff file: rh"); %! fail ("Tiff ([tempname() \".tif\"], \"r\")", "Failed to open Tiff file"); ## test one-pixel grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 1, "ImageWidth", 1, %! "BitsPerSample", 8)); %! data = uint8 (randi (intmax ("uint8"), 1, 1)); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [1, 1]); %! endfunction %! file_wrapper (@test_fn); ## test failure to write to image without dimensions %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! data = uint8 (randi (intmax ("uint8"), 1, 1)); %! fail ("writeEncodedStrip (img, 1, data)", "Failed to read image width"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test one row grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 1, "ImageWidth", 10, %! "BitsPerSample", 8)); %! data = uint8 (reshape (1:10, [1, 10])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [1, 10]); %! endfunction %! file_wrapper (@test_fn); ## test wrong size of row %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 1, "ImageWidth", 10, %! "BitsPerSample", 8)); %! data = uint8 (reshape (1:13, [1, 13])); %! fail ("writeEncodedStrip (img, 1, data)", "warning", %! "The image width is 10 but the input has 13 columns."); %! img.close (); %! verify_data (filename, data, [1, 10]); %! endfunction %! file_wrapper (@test_fn); ## test one strip grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8)); %! data = uint8 (reshape (1:100, [10, 10])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test wrong height of strip %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8)); %! data = uint8 (reshape (1:110, [11, 10])); %! fail ("writeEncodedStrip (img, 1, data)", "warning", %! "The strip is composed of 10 rows but the input has 11 rows."); %! img.close (); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test one strip RGB image chunky planes (RGBRGBRGB) %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:300, [10, 10, 3])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test wrong number of channels %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:400, [10, 10, 4])); %! fail ("writeEncodedStrip (img, 1, data)", "warning", %! "The strip is composed of 3 channels but the input has 4 channels."); %! img.close (); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test one strip RGB image separate planes (RRRGGGBBB) %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PlanarConfiguration", 2, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:300, [10, 10, 3])); %! for i = 1:3 %! writeEncodedStrip (img, i, data(:,:,i)); %! endfor %! img.close (); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test 1-bit BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test 16-bit grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16)); %! data = uint16 (reshape (1:400, [20, 20])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test 32-bit grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 32)); %! data = uint32 (reshape (1:400, [20, 20])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test 16-bit RGB image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1200, [20, 20, 3])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test 32-bit RGB image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 32, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint32 (reshape (1:1200, [20, 20, 3])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test failure unsupported bit-depth %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 24)); %! data = uint16 (reshape (1:400, [20, 20])); %! fail ("writeEncodedStrip (img, 1, data)", "Unsupported bit depth"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test failure unsupported BiLevel number of channels %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "SamplesPerPixel", 3)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! fail ("writeEncodedStrip (img, 1, data)", %! "Bi-Level images must have one channel only"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test multi-strip BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 10, "ImageWidth", 10, %! "RowsPerStrip", 2)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! for strip = 1:5 %! writeEncodedStrip (img, strip, data(strip * 2 - 1: strip * 2, :)); %! endfor %! img.close (); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test multi-strip grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "RowsPerStrip", 3)); %! data = uint16 (reshape (1:400, [20, 20])); %! for strip = 1:7 %! writeEncodedStrip (img, strip, data(strip * 3 - 2: min(strip * 3, 20), :)); %! endfor %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test multi-strip RGB image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "RowsPerStrip", 2, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1200, [20, 20, 3])); %! for strip = 1:10 %! writeEncodedStrip (img, strip, data(strip * 2 - 1: strip * 2, :, :)); %! endfor %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test multi-strip RGB separate planes image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "RowsPerStrip", 3, "PlanarConfiguration", 2, %! "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1200, [20, 20, 3])); %! strip = 1; %! for sample = 1:3 %! for row = 1:3:20 %! writeEncodedStrip (img, strip, data(row: min(row + 2, 20), :, sample)); %! strip = strip + 1; %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test single-precision image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 32, "SampleFormat", 3)); %! data = single (reshape (1:400, [20, 20])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test double-precision image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 64, "SampleFormat", 3)); %! data = double (reshape (1:400, [20, 20])); %! writeEncodedStrip (img, 1, data); %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test failure unsupported floating-point bit depth %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SampleFormat", 3)); %! data = double (reshape (1:400, [20, 20])); %! fail ("writeEncodedStrip (img, 1, data)", %! "Floating point images are only supported for bit depths of 32 and 64"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test failure data-type and bit-depth mismatch %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:1200, [20, 20, 3])); %! fail ("writeEncodedStrip (img, 1, data)", "Only uint16 data is allowed for uint images with bit depth of 16"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test failure writing to img read-only file %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 1, "ImageWidth", 1, %! "BitsPerSample", 8)); %! data = uint8 (1); %! writeEncodedStrip (img, 1, data); %! img.close(); %! img = Tiff (filename, "r"); %! fail ("writeEncodedStrip(img, 1, [1])", "Can't write data to a file opened in read-only mode"); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test failure unsupported sample format %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SampleFormat", 5)); %! data = double (reshape (1:400, [20, 20])); %! fail ("writeEncodedStrip (img, 1, data)", "Unsupported sample format"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test failure wrong strip number %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "RowsPerStrip", 5)); %! strip_data = uint16 (reshape (1:100, [5, 20])); %! fail ("writeEncodedStrip (img, 5, strip_data)", %! "Strip number out of range"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test failure writing strips to tiled image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "TileLength", 16, %! "TileWidth", 16)); %! data = uint8 (reshape (1:400, [20, 20])); %! fail ("writeEncodedStrip (img, 1, data)", %! "Can't write strips to a tiled image"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test tiled BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 32, "ImageWidth", 32, %! "TileLength", 16, "TileWidth", 16)); %! data = logical (repmat ([1,0,0,1,0,1,1,0], [32, 4])); %! tile = 1; %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:row+15, col:col+15)); %! tile = tile + 1; %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [32, 32]); %! endfunction %! file_wrapper (@test_fn); ## test tiled grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 32, "ImageWidth", 32, %! "BitsPerSample", 16, "TileLength", 16, %! "TileWidth", 16)); %! data = uint16 (reshape (1:1024, [32, 32])); %! tile = 1; %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:row+15, col:col+15)); %! tile = tile + 1; %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [32, 32]); %! endfunction %! file_wrapper (@test_fn); ## test tiled grayscale image with padding %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "TileLength", 16, %! "TileWidth", 16)); %! data = uint16 (reshape (1:400, [20, 20])); %! tile = 1; %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:min(row+15, 20), %! col:min(col+15, 20))); %! tile = tile + 1; %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [20, 20]); %! endfunction %! file_wrapper (@test_fn); ## test tiled RGB image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, "TileLength", 16, %! "TileWidth", 16, "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1200, [20, 20, 3])); %! tile = 1; %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:min(row+15,20), %! col:min(col+15,20), :)); %! tile = tile + 1; %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test tiled RGB image separate planes %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PlanarConfiguration", 2, "TileLength", 16, %! "TileWidth", 16, "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1200, [20, 20, 3])); %! tile = 1; %! for channel=1:3 %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:min(row+15,20), %! col:min(col+15,20), channel)); %! tile = tile + 1; %! endfor %! endfor %! endfor %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test failure writing tiles to stripped image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16)); %! data = uint8 (reshape (1:400, [20, 20])); %! fail ("writeEncodedTile (img, 1, data)", %! "Can't write tiles to a stripped image"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test tiled image wrong tile dimensions %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PlanarConfiguration", 1, "TileLength", 16, %! "TileWidth", 16, "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:1600, [20, 20, 4])); %! tile = 1; %! for row = 1:16:32 %! for col = 1:16:32 %! writeEncodedTile (img, tile, data(row:min(row+15,20), %! col:min(col+15,20), 1:3)); %! tile = tile + 1; %! endfor %! endfor %! fail ("writeEncodedTile (img, 1, data(1:18,1:16,1:3))", "warning", %! "The tile is composed of 16 rows but input has 18 rows"); %! fail ("writeEncodedTile (img, 1, data(1:16,1:20,1:3))", "warning", %! "The tile is composed of 16 columns but input has 20 columns"); %! fail ("writeEncodedTile (img, 1, data(1:16,1:16,:))", "warning", %! "The tile is composed of 3 channels but input has 4 channels"); %! img.close (); %! verify_data (filename, data, [20, 20, 3]); %! endfunction %! file_wrapper (@test_fn); ## test failure wrong tile number %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageLength", 20, "ImageWidth", 20, %! "BitsPerSample", 16, "TileWidth", 16, %! "TileLength", 16)); %! tile_data = uint16 (reshape (1:256, [16, 16])); %! fail ("writeEncodedTile (img, 5, tile_data)", %! "Tile number out of range"); %! img.close (); %! endfunction %! file_wrapper (@test_fn); ## test isTiled returns the correct value %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! assert (isTiled (img), logical (0)); %! setTag (img, "TileLength", 16); %! setTag (img, "TileWidth", 16); %! assert (isTiled (img), logical (1)); %! endfunction %! file_wrapper (@test_fn); ## test numberOfStrips returns the correct value %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageWidth", 10, "ImageLength", 10)); %! assert (numberOfStrips (img), 1); %! setTag (img, "RowsPerStrip", 2); %! assert (numberOfStrips (img), 5); %! setTag (img, "RowsPerStrip", 4); %! assert (numberOfStrips (img), 3); %! setTag (img, "TileLength", 16); %! setTag (img, "TileWidth", 16); %! fail ("numberOfStrips (img)", "The image is tiled not stripped"); %! endfunction %! file_wrapper (@test_fn); ## test numberOfTiles returns the correct value %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageWidth", 20, "ImageLength", 20, %! "TileLength", 16, "TileWidth", 16)); %! assert (numberOfTiles (img), 4); %! setTag (img, "TileLength", 32); %! assert (numberOfTiles (img), 2); %! setTag (img, "TileWidth", 32); %! assert (numberOfTiles (img), 1); %! img = Tiff (filename, "w"); %! fail ("numberOfTiles (img)", "The image is stripped not tiled"); %! endfunction %! file_wrapper (@test_fn); ## test computeStrip returns the correct value %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageWidth", 10, "ImageLength", 10, %! "RowsPerStrip", 2, "BitsPerSample", 8, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1)); %! assert (computeStrip (img, 1), 1); %! assert (computeStrip (img, 2), 1); %! assert (computeStrip (img, 0), 1); %! assert (computeStrip (img, 10), 5); %! assert (computeStrip (img, 11), 5); %! setTag (img, "PlanarConfiguration", 2); %! ## This is need for the tag to take effect, should be %! ## replaced by rewriteDirectory %! writeEncodedStrip (img, 1, uint8 (reshape (1:20, [2, 10]))); %! assert (computeStrip (img, 1, 2), 6); %! assert (computeStrip (img, 100, 1), 5); %! img = Tiff (filename, "w"); %! setTag (img, "TileWidth", 16); %! setTag (img, "TileLength", 16); %! fail ("computeStrip (img, 1, 1)", "The image is tiled not stripped"); %! endfunction %! file_wrapper (@test_fn); ## test computeTile returns the correct value %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag (img, struct ("ImageWidth", 20, "ImageLength", 20, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "TileLength", 16, "TileWidth", 16, %! "PlanarConfiguration", 1)); %! assert (computeTile (img, [1, 1]), 1); %! assert (computeTile (img, [2, 2]), 1); %! assert (computeTile (img, [0, 0]), 1); %! assert (computeTile (img, [8, 17]), 2); %! assert (computeTile (img, [19, 10]), 3); %! assert (computeTile (img, [17, 17]), 4); %! assert (computeTile (img, [100, 100]), 4); %! setTag (img, "PlanarConfiguration", 2); %! ## This is need for the tag to take effect, should be %! ## replaced by rewriteDirectory %! writeEncodedTile (img, 1, uint8 (reshape (1:256, [16, 16]))); %! assert (computeTile (img, [1, 1], 2), 5); %! assert (computeTile (img, [100, 100], 1), 4); %! img = Tiff (filename, "w"); %! fail ("computeTile (img, 1, 1)", "The image is stripped not tiled"); %! endfunction %! file_wrapper (@test_fn); ## test write method one pixel bilevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 1, "ImageWidth", 1)); %! write (img, logical ([1])); %! img.close(); %! verify_data (filename, logical ([1]), [1, 1]); %! endfunction %! file_wrapper (@test_fn); ## test write method one strip bilevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test write method multi-strip bilevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "RowsPerStrip", 3)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test write method one pixel grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 1, "ImageWidth", 1, %! "BitsPerSample", 8)); %! write (img, uint8 ([255])); %! img.close(); %! verify_data (filename, uint8 ([255]), [1, 1]); %! endfunction %! file_wrapper (@test_fn); ## test write method one strip grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8)); %! data = uint8 (reshape (1:100, [10, 10])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test write method multi-strip grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "RowsPerStrip", 3)); %! data = uint8 (reshape (1:100, [10, 10])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10]); %! endfunction %! file_wrapper (@test_fn); ## test write method multi-strip RGB image chunky %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method multi-strip RGB image separate %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 2, %! "PhotometricInterpretation", 2)); %! data = uint8 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method 16-bit multi-strip image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 16, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint16 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method 32-bit multi-strip image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 32, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2)); %! data = uint32 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method single-precision image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 32, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2, "SampleFormat", 3)); %! data = single (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method single-precision image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 64, "RowsPerStrip", 3, %! "SamplesPerPixel", 3, "PlanarConfiguration", 1, %! "PhotometricInterpretation", 2, "SampleFormat", 3)); %! data = double (reshape (1:300, [10, 10, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [10, 10, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method tiled BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [40, 4])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40]); %! endfunction %! file_wrapper (@test_fn); ## test write method tiled grayscale image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 16)); %! data = uint16 (reshape (1:1600, [40, 40])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40]); %! endfunction %! file_wrapper (@test_fn); ## test write method tiled RGB image chunky %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1)); %! data = uint16 (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method tiled RGB image separate %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 2)); %! data = uint16 (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method 32-bit tiled image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 32, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1)); %! data = uint32 (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method single-precision tiled image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 32, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, "SampleFormat", 3)); %! data = single (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40, 3]); %! endfunction %! file_wrapper (@test_fn); ## test write method double-precision tiled image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 64, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, "SampleFormat", 3)); %! data = double (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! img.close(); %! verify_data (filename, data, [40, 40, 3]); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedStrip BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "RowsPerStrip", 6)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [10, 1])); %! write (img, data); %! s1 = readEncodedStrip (img, 1); %! s2 = readEncodedStrip (img, 2); %! assert ([s1;s2], data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedStrip RGB Chunky %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, "RowsPerStrip", 6, %! "PlanarConfiguration", 1)); %! data = uint16 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! s1 = readEncodedStrip (img, 1); %! s2 = readEncodedStrip (img, 2); %! assert ([s1;s2], data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedStrip RGB Separated %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, "RowsPerStrip", 6, %! "PlanarConfiguration", 2)); %! data = uint16 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! s = cell (6, 1); %! for i=1:6 %! s{i} = readEncodedStrip (img, i); %! endfor %! data2 = cat (3, [s{1}; s{2}], [s{3}; s{4}], [s{5}; s{6}]); %! assert (data2, data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedTile BiLevel image %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16)); %! data = logical (repmat ([1,0,0,0,1,0,1,1,1,0], [40, 4])); %! write (img, data); %! t = cell (9, 1); %! for i=1:9 %! t{i} = readEncodedTile (img, i); %! endfor %! data2 = cat(1, cat (2, t{1}, t{2}, t{3}), cat (2, t{4}, t{5}, t{6}), %! cat (2, t{7}, t{8}, t{9})); %! assert (data2, data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedTile RGB Chunky %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1)); %! data = uint16 (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! t = cell (9, 1); %! for i=1:9 %! t{i} = readEncodedTile (img, i); %! endfor %! data2 = cat(1, cat (2, t{1}, t{2}, t{3}), cat (2, t{4}, t{5}, t{6}), %! cat (2, t{7}, t{8}, t{9})); %! assert (data2, data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readEncodedTile RGB Separated %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ("ImageLength", 40, "ImageWidth", 40, %! "TileWidth", 16, "TileLength", 16, %! "BitsPerSample", 16, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 2)); %! data = uint16 (reshape (1:4800, [40, 40, 3])); %! write (img, data); %! data2 = uint16 (zeros (40, 40, 3)); %! tile = 1; %! for sample=1:3 %! for row=1:16:40 %! for col=1:16:40 %! data2(row: min(40, row + 15), col: min(40, col + 15), sample)... %! = readEncodedTile(img, tile); %! tile += 1; %! endfor %! endfor %! endfor %! assert (data2, data); %! img.close(); %! endfunction %! file_wrapper (@test_fn); ## test readRGBAImage %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1 %! )); %! data = uint8 (reshape (1:300, [10, 10, 3])); %! write (img, data); %! [rgb, alpha] = readRGBAImage (img); %! assert (rgb, data); %! assert (alpha, uint8 (repmat ([255], [10, 10]))); %! endfunction %! file_wrapper (@test_fn); ## test readRGBAImage with alpha %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 4, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "ExtraSamples", 1 %! )); %! data = uint8 (randi ([0,255], [10, 10, 4])); %! write (img, data); %! [rgb, alpha] = readRGBAImage (img); %! assert (rgb, data(:,:,1:3)); %! assert (alpha, data(:,:,4)); %! endfunction %! file_wrapper (@test_fn); ## test readRGBAStrip %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "RowsPerStrip", 3 %! )); %! data = uint8 (randi ([0,255], [10, 10, 3])); %! write (img, data); %! [rgb, alpha] = readRGBAStrip (img, 1); %! assert (rgb, data(1:3,:,:)); %! assert (alpha, uint8 (repmat ([255], [3, 10]))); %! endfunction %! file_wrapper (@test_fn); ## test readRGBAStrip boundary strip %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "RowsPerStrip", 3 %! )); %! data = uint8 (randi ([0,255], [10, 10, 3])); %! write (img, data); %! [rgb, alpha] = readRGBAStrip (img, 10); %! assert (rgb, data(10,:,:)); %! assert (alpha, uint8 (repmat ([255], [1, 10]))); %! endfunction %! file_wrapper (@test_fn); ## test readRGBAStrip with alpha %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 10, "ImageWidth", 10, %! "BitsPerSample", 8, "SamplesPerPixel", 4, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "RowsPerStrip", 3, %! "ExtraSamples", 1 %! )); %! data = uint8 (randi ([0,255], [10, 10, 4])); %! write (img, data); %! [rgb, alpha] = readRGBAStrip (img, 1); %! assert (rgb, data(1:3,:, 1:3)); %! assert (alpha, data (1:3, :, 4)); %! endfunction %! file_wrapper (@test_fn); ## test readRGBATile %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 40, "ImageWidth", 40, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "TileLength", 16, "TileWidth", 32 %! )); %! data = uint8 (randi ([0,255], [40, 40, 3])); %! write (img, data); %! [rgb, alpha] = readRGBATile (img, 1, 1); %! assert (rgb, data(1:16,1:32,:)); %! assert (alpha, uint8 (repmat ([255], [16, 32]))); %! endfunction %! file_wrapper (@test_fn); ## test readRGBATile boundary tile %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 40, "ImageWidth", 40, %! "BitsPerSample", 8, "SamplesPerPixel", 3, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "TileLength", 16, "TileWidth", 32 %! )); %! data = uint8 (randi ([0,255], [40, 40, 3])); %! write (img, data); %! [rgb, alpha] = readRGBATile (img, 40, 40); %! assert (rgb, data(33:end,33:end,:)); %! assert (alpha, uint8 (repmat ([255], [8, 8]))); %! endfunction %! file_wrapper (@test_fn); ## test readRGBATile ith alpha %!testif HAVE_TIFF %! function test_fn (filename) %! img = Tiff (filename, "w"); %! setTag(img, struct ( %! "ImageLength", 40, "ImageWidth", 40, %! "BitsPerSample", 8, "SamplesPerPixel", 4, %! "PhotometricInterpretation", 2, %! "PlanarConfiguration", 1, %! "TileLength", 16, "TileWidth", 32, %! "ExtraSamples", 1 %! )); %! data = uint8 (randi ([0,255], [40, 40, 4])); %! write (img, data); %! [rgb, alpha] = readRGBATile (img, 1, 1); %! assert (rgb, data(1:16,1:32,1:3)); %! assert (alpha, data(1:16,1:32,4)); %! endfunction %! file_wrapper (@test_fn);