octave-libtiff: libinterp/dldfcn/__tiff_

comparison libinterp/dldfcn/tiff.cc @ 31158:f2ae7763739a

Tiff: added writeEncodedTile method to read tiles from image * __tiff__.cc(F__tiff_read_encoded_tile__): added internal function to process readEncodedTile arguments. * __tiff__.cc(read_tile): implemented logic for reading tile from image file. * __tiff__.cc(handle_read_strip_or_tile): refactores common logic between read_strip and read_tile into a function. * Tiff.m: added readEncodedTile method to the Tiff class and added the necessary unit tests.

author	magedrifaat <magedrifaat@gmail.com>
date	Sat, 06 Aug 2022 21:59:26 +0200
parents	dc3d2744916d
children	e960e3a3b3f6

comparison

equal deleted inserted replaced

-:dc3d2744916d
+:f2ae7763739a
 strip_dims = dim_vector (image_data->width, rows_in_strip, 1);
 else
 error ("Unsupported bit depth");
 T strip_data (strip_dims);
+uint8_t *strip_fvec
-if (TIFFReadEncodedStrip (tif, strip_no,
+= reinterpret_cast<uint8_t *> (strip_data.fortran_vec ());
-strip_data.fortran_vec (), -1) == -1)
-error ("Failed to read strip data");
+if (image_data->bits_per_sample == 8
+|| image_data->bits_per_sample == 16
+|| image_data->bits_per_sample == 32
+|| image_data->bits_per_sample == 64)
+{
+if (TIFFReadEncodedStrip (tif, strip_no, strip_fvec, -1) == -1)
+error ("Failed to read strip data");
+}
+else if (image_data->bits_per_sample == 1)
+{
+if (image_data->samples_per_pixel != 1)
+error ("Bi-Level images must have one channel only");
+// Create a buffer to hold the packed strip data
+// Unique pointers are faster than vectors for constant size buffers
+std::unique_ptr<uint8_t []> strip_ptr
+= std::make_unique<uint8_t []> (TIFFStripSize (tif));
+uint8_t *strip_buf = strip_ptr.get ();
+if (TIFFReadEncodedStrip (tif, strip_no, strip_buf, -1) == -1)
+error ("Failed to read strip data");
+// According to the format specification, the row should be byte
+// aligned so the number of bytes is rounded up to the nearest byte
+uint32_t padded_width = (image_data->width + 7) / 8;
+// Packing the pixel data into bits
+for (uint32_t row = 0; row < rows_in_strip; row++)
+{
+for (uint32_t col = 0; col < image_data->width; col++)
+{
+uint8_t shift = 7 - col % 8;
+strip_fvec[col] = (strip_buf[col / 8] >> shift) & 0x1;
+}
+strip_fvec += image_data->width;
+strip_buf += padded_width;
+}
+}
+else
+error ("Unsupported bit depth");
 Array<octave_idx_type> perm (dim_vector (3, 1));
 if (image_data->planar_configuration == PLANARCONFIG_CONTIG)
 {
 perm(0) = 2;
 perm(2) = 2;
 }
 strip_data = strip_data.permute (perm);
 return octave_value (strip_data);
+}
+template <typename T>
+octave_value
+read_tile (TIFF *tif, uint32_t tile_no, tiff_image_data *image_data)
+{
+// ASSUMES tiled image and tile_no is a valid zero-based tile
+// index for the tif image
+// TODO(maged): check matlab behavior
+// TODO(maged): refactor into a function?
+uint32_t tile_width, tile_height;
+if (! TIFFGetField (tif, TIFFTAG_TILELENGTH, &tile_height))
+error ("Filed to read tile length");
+if (! TIFFGetField (tif, TIFFTAG_TILEWIDTH, &tile_width))
+error ("Filed to read tile length");
+if (tile_height == 0 || tile_height % 16 != 0
+|| tile_width == 0 || tile_width % 16 != 0)
+error ("Tile dimesion tags are invalid");
+dim_vector tile_dims;
+if (image_data->planar_configuration == PLANARCONFIG_CONTIG)
+{
+tile_dims = dim_vector (image_data->samples_per_pixel, tile_width,
+tile_height);
+}
+else if (image_data->planar_configuration == PLANARCONFIG_SEPARATE)
+{
+tile_dims = dim_vector (tile_width, tile_height, 1);
+}
+else
+error ("Unsupported planar configuration");
+T tile_data (tile_dims);
+uint8_t *tile_fvec
+= reinterpret_cast<uint8_t *> (tile_data.fortran_vec ());
+if (image_data->bits_per_sample == 8
+|| image_data->bits_per_sample == 16
+|| image_data->bits_per_sample == 32
+|| image_data->bits_per_sample == 64)
+{
+if (TIFFReadEncodedTile (tif, tile_no, tile_fvec, -1) == -1)
+error ("Failed to read tile data");
+}
+else if (image_data->bits_per_sample == 1)
+{
+if (image_data->samples_per_pixel != 1)
+error ("Bi-Level images must have one channel only");
+// Create a buffer to hold the packed tile data
+// Unique pointers are faster than vectors for constant size buffers
+std::unique_ptr<uint8_t []> tile_ptr
+= std::make_unique<uint8_t []> (TIFFTileSize (tif));
+uint8_t *tile_buf = tile_ptr.get ();
+if (TIFFReadEncodedTile (tif, tile_no, tile_buf, -1) == -1)
+error ("Failed to read tile data");
+// unpack tile bits into output matrix cells
+for (uint32_t row = 0; row < tile_height; row++)
+{
+for (uint32_t col = 0; col < tile_width; col++)
+{
+uint8_t shift = 7 - col % 8;
+tile_fvec[col] = (tile_buf [col / 8] >> shift) & 0x1;
+}
+tile_fvec += tile_width;
+tile_buf += tile_width / 8;
+}
+}
+else
+error ("Unsupported bit depth");
+Array<octave_idx_type> perm (dim_vector (3, 1));
+if (image_data->planar_configuration == PLANARCONFIG_CONTIG)
+{
+perm(0) = 2;
+perm(1) = 1;
+perm(2) = 0;
+}
+else if (image_data->planar_configuration == PLANARCONFIG_SEPARATE)
+{
+perm(0) = 1;
+perm(1) = 0;
+perm(2) = 2;
+}
+tile_data = tile_data.permute (perm);
+// Get the actual tile dimensions
+uint32_t tiles_across = (image_data->width + tile_width - 1)
+/ tile_width;
+uint32_t tiles_down = (image_data->height + tile_height - 1)
+/ tile_height;
+uint32_t corrected_width = tile_width;
+uint32_t corrected_height = tile_height;
+if (tile_no % tiles_across == tiles_across - 1)
+corrected_width = image_data->width - tile_width * (tiles_across - 1);
+if ((tile_no / tiles_across) % tiles_down == tiles_down - 1)
+corrected_height = image_data->height - tile_height * (tiles_down - 1);
+dim_vector corrected_dims;
+if (image_data->planar_configuration == PLANARCONFIG_CONTIG)
+corrected_dims = dim_vector (corrected_height, corrected_width,
+image_data->samples_per_pixel);
+else if (image_data->planar_configuration == PLANARCONFIG_SEPARATE)
+corrected_dims = dim_vector (corrected_height, corrected_width);
+// TODO(maged): confirm matlab behavior
+tile_data.resize (corrected_dims);
+return octave_value (tile_data);
+}
+template <typename T>
+octave_value
+read_strip_or_tile (TIFF *tif, uint32_t strip_tile_no,
+tiff_image_data *image_data)
+{
+if (image_data->is_tiled)
+return read_tile<T> (tif, strip_tile_no, image_data);
+else
+return read_strip<T> (tif, strip_tile_no, image_data);
+}
+octave_value
+handle_read_strip_or_tile (TIFF *tif, uint32_t strip_tile_no)
+{
+// Obtain all necessary tags
+tiff_image_data image_data (tif);
+uint16_t sample_format;
+if (! TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLEFORMAT, &sample_format))
+error ("Failed to obtain a value for sample format");
+if (sample_format == 3)
+{
+if (image_data.bits_per_sample != 32
+&& image_data.bits_per_sample != 64)
+error ("Floating point images are only supported for bit depths of 32 and 64");
+}
+else if (sample_format != 1 && sample_format != 4)
+error ("Unsupported sample format");
+switch (image_data.bits_per_sample)
+{
+case 1:
+return read_strip_or_tile<boolNDArray> (tif, strip_tile_no,
+&image_data);
+break;
+case 8:
+return read_strip_or_tile<uint8NDArray> (tif, strip_tile_no,
+&image_data);
+break;
+case 16:
+return read_strip_or_tile<uint16NDArray> (tif, strip_tile_no,
+&image_data);
+break;
+case 32:
+if (sample_format == 3)
+return read_strip_or_tile<FloatNDArray> (tif, strip_tile_no,
+&image_data);
+else
+return read_strip_or_tile<uint32NDArray> (tif, strip_tile_no,
+&image_data);
+break;
+case 64:
+if (sample_format == 3)
+return read_strip_or_tile<NDArray> (tif, strip_tile_no,
+&image_data);
+else
+return read_strip_or_tile<uint64NDArray> (tif, strip_tile_no,
+&image_data);
+break;
+default:
+error ("Unsupported bit depth");
+}
 }
 template <typename T>
 octave_value
 read_stripped_image (TIFF *tif, tiff_image_data *image_data)
 else
 write_strip<T> (tif, strip_tile_no, strip_data, image_data);
 }
 void
-process_strip_or_tile (TIFF *tif, uint32_t strip_tile_no,
+handle_write_strip_or_tile (TIFF *tif, uint32_t strip_tile_no,
-octave_value data_ov, tiff_image_data *image_data)
+octave_value data_ov,
+tiff_image_data *image_data)
 {
 // SampleFormat tag is not a required field and has a default value of 1
 // So we need to use TIFFGetFieldDefaulted in case it is not present in
 // the file
 err_disabled_feature ("read", "Tiff");
 #endif
 }
 DEFUN_DLD (__tiff_read_encoded_strip__, args, nargout,
-"Read the image in the current IFD")
+"Read a strip from the image in the current IFD")
 {
 #if defined (HAVE_TIFF)
 int nargin = args.length ();
 if (nargin != 2)
 error ("Strip number out of bounds");
 // Convert from Octave's 1-based indexing to zero-based indexing
 strip_no--;
-// Obtain all necessary tags
+return octave_value_list (handle_read_strip_or_tile (tif, strip_no));
-tiff_image_data image_data (tif);
+#else
+err_disabled_feature ("readEncodedStrip", "Tiff");
-uint16_t sample_format;
+#endif
-if (! TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLEFORMAT, &sample_format))
+}
-error ("Failed to obtain a value for sample format");
+DEFUN_DLD (__tiff_read_encoded_tile__, args, nargout,
-if (sample_format == 3)
+"Read a tile from the image in the current IFD")
 {
-if (image_data.bits_per_sample != 32 && image_data.bits_per_sample != 64)
+#if defined (HAVE_TIFF)
-error ("Floating point images are only supported for bit depths of 32 and 64");
+int nargin = args.length ();
-}
-else if (sample_format != 1 && sample_format != 4)
+if (nargin != 2)
-error ("Unsupported sample format");
+error ("rong number of arguments");
-octave_value_list retval;
+TIFF *tif = (TIFF *)(args(0).uint64_value ());
-switch (image_data.bits_per_sample)
-{
+// TODO(maged): nargout and ycbcr
-case 1:
+octave_unused_parameter (nargout);
-retval(0) = read_strip<boolNDArray> (tif, strip_no, &image_data);
-break;
+if (! TIFFIsTiled (tif))
-case 8:
+error ("The image is stripped not tiled");
-retval(0) = read_strip<uint8NDArray> (tif, strip_no, &image_data);
-break;
+// TODO(maged): what is the behavior in matlab
-case 16:
+uint32_t tile_no;
-retval(0) = read_strip<uint16NDArray> (tif, strip_no, &image_data);
+if (args(1).is_scalar_type ())
-break;
+tile_no = args(1).uint32_scalar_value ();
-case 32:
+else
-if (sample_format == 3)
+error ("Expected scalar for tile number");
-retval(0) = read_strip<FloatNDArray> (tif, strip_no, &image_data);
-else
+if (tile_no < 1 || tile_no > TIFFNumberOfTiles (tif))
-retval(0) = read_strip<uint32NDArray> (tif, strip_no, &image_data);
+error ("Tile number out of bounds");
-break;
-case 64:
+// Convert from Octave's 1-based indexing to zero-based indexing
-if (sample_format == 3)
+tile_no--;
-retval(0) = read_strip<NDArray> (tif, strip_no, &image_data);
-else
+return octave_value_list (handle_read_strip_or_tile (tif, tile_no));
-retval(0) = read_strip<uint64NDArray> (tif, strip_no, &image_data);
-break;
-default:
-error ("Unsupported bit depth");
-}
-return retval;
 #else
 err_disabled_feature ("readEncodedStrip", "Tiff");
 #endif
 }
 uint32_t strip_no = args(1).uint32_scalar_value ();
 if (strip_no < 1 || strip_no > TIFFNumberOfStrips (tif))
 error ("Strip number out of range");
-process_strip_or_tile (tif, strip_no, args(2), &image_data);
+handle_write_strip_or_tile (tif, strip_no, args(2), &image_data);
 return octave_value_list ();
 #else
 err_disabled_feature ("writeEncodedStrip", "Tiff");
 #endif
 uint32_t tile_no = args(1).uint32_scalar_value ();
 if (tile_no < 1 || tile_no > TIFFNumberOfTiles (tif))
 error ("Tile number out of range");
-process_strip_or_tile (tif, tile_no, args(2), &image_data);
+handle_write_strip_or_tile (tif, tile_no, args(2), &image_data);
 return octave_value_list ();
 #else
 err_disabled_feature ("writeEncodedTile", "Tiff");
 #endif

Mercurial > octave-libtiff

comparison libinterp/dldfcn/__tiff__.cc @ 31158:f2ae7763739a

comparison libinterp/dldfcn/tiff.cc @ 31158:f2ae7763739a