C# Class BitMiracle.LibTiff.Classic.Tiff

Converts a byte buffer into array of 32-bit values.

Converts a byte buffer into array of 16-bit values.

Checks whether the specified (x, y, z, plane) coordinates are within the bounds of the image.

The x parameter is checked against the value of the TiffTag.IMAGEWIDTH tag. The y parameter is checked against the value of the TiffTag.IMAGELENGTH tag. The z parameter is checked against the value of the TiffTag.IMAGEDEPTH tag (if defined). The plane parameter is checked against the value of the TiffTag.SAMPLESPERPIXEL tag if the data are organized in separate planes.

Writes the current state of the TIFF directory into the file to make what is currently in the file/stream readable.

Unlike WriteDirectory, CheckpointDirectory does not free up the directory data structures in memory, so they can be updated (as strips/tiles are written) and written again. Reading such a partial file you will at worst get a TIFF read error for the first strip/tile encountered that is incomplete, but you will at least get all the valid data in the file before that. When the file is complete, just use WriteDirectory as usual to finish it off cleanly.

Initializes new instance of Tiff class and opens a stream with TIFF data for reading or writing.

This method can be used to read TIFF data from sources other than file. When custom stream class derived from TiffStream is used it is possible to read (or write) TIFF data that reside in memory, database, etc.

Please note, that name is an arbitrary string used as ID for the created Tiff. It's not required to be a file name or anything meaningful at all.

Please read remarks for Open(string, string) method for the list of option flags that can be specified in mode parameter.

Returns the custom client data associated with this Tiff.

Closes a previously opened TIFF file.

This method closes a file or stream that was previously opened with Open(string, string) or ClientOpen(string, string, object, BitMiracle.LibTiff.Classic.TiffStream). Any buffered data are flushed to the file/stream, including the contents of the current directory (if modified); and all resources are reclaimed.

Compares specified number of elements in two arrays.

Computes which strip contains the specified coordinates (row, plane).

A valid strip number is always returned; out-of-range coordinate values are clamped to the bounds of the image. The row parameter is always used in calculating a strip. The plane parameter is used only if data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE).

Computes which tile contains the specified coordinates (x, y, z, plane).

A valid tile number is always returned; out-of-range coordinate values are clamped to the bounds of the image. The x and y parameters are always used in calculating a tile. The z parameter is used if the image is deeper than 1 slice (TiffTag.IMAGEDEPTH > 1). The plane parameter is used only if data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE).

Creates a new directory within file/stream.

The newly created directory will not exist on the file/stream till WriteDirectory, CheckpointDirectory, Flush or Close is called.

Retrieves the file/stream offset of the current directory.

Gets the zero-based index of the current directory.

The zero-based index returned by this method is suitable for use with the SetDirectory method.

Gets the current row that is being read or written.

The current row is updated each time a read or write is done.

Gets the current strip that is being read or written.

The current strip is updated each time a read or write is done.

Gets the current tile that is being read or written.

The current tile is updated each time a read or write is done.

Gets the number of bytes occupied by the item of given type.

Computes the number of rows for a reasonable-sized strip according to the current settings of the TiffTag.IMAGEWIDTH, TiffTag.BITSPERSAMPLE and TiffTag.SAMPLESPERPIXEL tags and any compression-specific requirements.

If the estimate parameter is non-zero, then it is taken as an estimate of the desired strip size and adjusted according to any compression-specific requirements. The value returned by DefaultStripSize is typically used to define the TiffTag.ROWSPERSTRIP tag. If there is no any unusual requirements DefaultStripSize tries to create strips that have approximately 8 kilobytes of uncompressed data.

Computes the pixel width and height of a reasonable-sized tile suitable for setting up the TiffTag.TILEWIDTH and TiffTag.TILELENGTH tags.

If the width and height values passed in are non-zero, then they are adjusted to reflect any compression-specific requirements. The returned width and height are constrained to be a multiple of 16 pixels to conform with the TIFF specification.

Frees and releases all resources allocated by this Tiff.

Invokes the library-wide error handling methods to (normally) write an error message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which an error is detected.

Applications that desire to capture control in the event of an error should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide error handling methods to (normally) write an error message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which an error is detected.

Applications that desire to capture control in the event of an error should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide error handling methods to (normally) write an error message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which an error is detected.

The clientData parameter can be anything you want. It will be passed unchanged to the error handler. Default error handler does not use it. Only custom error handlers may make use of it.

Applications that desire to capture control in the event of an error should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide error handling methods to (normally) write an error message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which an error is detected.

The clientData parameter can be anything you want. It will be passed unchanged to the error handler. Default error handler does not use it. Only custom error handlers may make use of it.

Applications that desire to capture control in the event of an error should use SetErrorHandler to override the default error and warning handler.

Retrieves field information for the tag with specified name.

Retrieves field information for the specified tag.

Gets the name of the file or ID string for this Tiff.

If this Tiff was created using Open(string, string) method then value of fileName parameter of Open(string, string) method is returned. If this Tiff was created using ClientOpen(string, string, object, BitMiracle.LibTiff.Classic.TiffStream) then value of name parameter of ClientOpen(string, string, object, BitMiracle.LibTiff.Classic.TiffStream) method is returned.

Retrieves the codec registered for the specified compression scheme.

LibTiff.Net supports a variety of compression schemes implemented by software codecs. Each codec adheres to a modular interface that provides for the decoding and encoding of image data; as well as some other methods for initialization, setup, cleanup, and the control of default strip and tile sizes. Codecs are identified by the associated value of the TiffTag.COMPRESSION tag.

Other compression schemes may be registered. Registered schemes can also override the built-in versions provided by the library.

Retrieves field information for the specified tag.

Retrieves field information for the tag with specified name.

Flushes pending writes to an open TIFF file.

Flush causes any pending writes for the specified file (including writes for the current directory) to be done. In normal operation this call is never needed − the library automatically does any flushing required.

Flushes any pending image data for the specified file to be written out.

FlushData flushes any pending image data for the specified file to be written out; directory-related data are not flushed. In normal operation this call is never needed − the library automatically does any flushing required.

Releases storage associated with current directory.

Gets the A component from ABGR value returned by ReadRGBAImage.

Gets the B component from ABGR value returned by ReadRGBAImage.

Retrieves a bit reversal table.

If reversed is false then the table that do not reverse bit values will be retrieved. It is a lookup table that can be used as an identity function; i.e. NoBitRevTable[n] == n.

Gets the extra information with specified name associated with this Tiff.

Retrieves an array of configured codecs, both built-in and registered by user.

Gets the value(s) of a tag in an open TIFF file.

GetField returns the value(s) of a tag or pseudo-tag associated with the current directory of the opened TIFF file. The tag is identified by tag. The type and number of values returned is dependent on the tag being requested. You may want to consult "Well-known tags and their value(s) data types" to become familiar with exact data types and calling conventions required for each tag supported by the library.

A pseudo-tag is a parameter that is used to control the operation of the library but whose value is not read or written to the underlying file.

Gets the value(s) of a tag in an open TIFF file or default value(s) of a tag if a tag is not defined in the current directory and it has a default value(s).

GetFieldDefaulted returns the value(s) of a tag or pseudo-tag associated with the current directory of the opened TIFF file or default value(s) of a tag if a tag is not defined in the current directory and it has a default value(s). The tag is identified by tag. The type and number of values returned is dependent on the tag being requested. You may want to consult "Well-known tags and their value(s) data types" to become familiar with exact data types and calling conventions required for each tag supported by the library.

A pseudo-tag is a parameter that is used to control the operation of the library but whose value is not read or written to the underlying file.

Gets the G component from ABGR value returned by ReadRGBAImage.

Gets the mode with which the underlying file or stream was opened.

Gets the R component from ABGR value returned by ReadRGBAImage.

Gets the tiff stream.

Gets the number of elements in the custom tag list.

Retrieves the custom tag with specified index.

Gets the currently used tag methods.

Gets the library version string.

Converts array of 32-bit values into array of bytes.

Gets the value indicating whether given image data was written in big-endian order.

Gets the value indicating whether the image data was in a different byte-order than the host computer.

Note that ReadTile, ReadEncodedTile, ReadEncodedStrip and O:BitMiracle.LibTiff.Classic.Tiff.ReadScanline methods already normally perform byte swapping to local host order if needed.

Also note that ReadRawTile and ReadRawStrip do not perform byte swapping to local host order.

Checks whether library has working codec for the specific compression scheme.

Gets the value indicating whether the image data is being returned in MSB-to-LSB bit order.

Gets the value indicating whether the image data of this Tiff has a tiled organization.

Gets the value indicating whether the image data returned through the read interface methods is being up-sampled.

The value returned by this method can be useful to applications that want to calculate I/O buffer sizes to reflect this usage (though the usual strip and tile size routines already do this).

Returns an indication of whether the current directory is the last directory in the file.

Merges given field information to existing one.

Gets the number of directories in a file.

Retrives the number of strips in the image.

Retrives the number of tiles in the image.

Initializes new instance of Tiff class and opens a TIFF file for reading or writing.

Open(string, string) opens a TIFF file whose name is fileName. When a file is opened for appending, existing data will not be touched; instead new data will be written as additional subfiles. If an existing file is opened for writing, all previous data is overwritten.

If a file is opened for reading, the first TIFF directory in the file is automatically read (see SetDirectory for reading directories other than the first). If a file is opened for writing or appending, a default directory is automatically created for writing subsequent data. This directory has all the default values specified in TIFF Revision 6.0: BitsPerSample = 1, ThreshHolding = Threshold.BILEVEL (bilevel art scan), FillOrder = MSB2LSB (most significant bit of each data byte is filled first), Orientation = TOPLEFT (the 0th row represents the visual top of the image, and the 0th column represents the visual left hand side), SamplesPerPixel = 1, RowsPerStrip = infinity, ResolutionUnit = INCH, and Compression = NONE. To alter these values, or to define values for additional fields, SetField must be used.

The mode parameter can include the following flags in addition to the "r", "w", and "a" flags. Note however that option flags must follow the read-write-append specification.

By default the library will create new files with the native byte-order of the CPU on which the application is run. This ensures optimal performance and is portable to any application that conforms to the TIFF specification. To force the library to use a specific byte-order when creating a new file the "b" and "l" option flags may be included in the mode parameter; for example, "wb" or "wl".

The use of the "l" and "b" flags is strongly discouraged. These flags are provided solely because numerous vendors do not correctly support TIFF; they only support one of the two byte orders. It is strongly recommended that you not use this feature except to deal with busted apps that write invalid TIFF.

The "L", "B", and "H" flags are intended for applications that can optimize operations on data by using a particular bit order. By default the library returns data in MSB2LSB bit order. Returning data in the bit order of the native CPU makes the most sense but also requires applications to check the value of the TiffTag.FILLORDER tag; something they probably do not do right now.

The "c" option permits applications that only want to look at the tags, for example, to get the unadulterated TIFF tag information.

Prints formatted description of the contents of the current directory to the specified stream.

Prints formatted description of the contents of the current directory to the specified stream using specified print (formatting) options.

Check the image to see if it can be converted to RGBA format.

To convert the image to RGBA format please use O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImage, O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImageOriented, ReadRGBAStrip or ReadRGBATile

Convertible images should follow this rules: samples must be either 1, 2, 4, 8, or 16 bits; colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Calculates the size in bytes of a complete decoded and packed raster scanline.

The value returned by RasterScanlineSize may be different from the value returned by ScanlineSize if data is stored as separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE).

Computes the number of bytes in a raw (i.e. not decoded) strip.

Computes the number of bytes in a raw (i.e. not decoded) tile.

Sets up the data buffer used to read raw (encoded) data from a file.

This method is provided for client-control of the I/O buffers used by the library. Applications need never use this method; it's provided only for "intelligent clients" that wish to optimize memory usage and/or eliminate potential copy operations that can occur when working with images that have data stored without compression.

If the buffer is null, then a buffer of appropriate size is allocated by the library. Otherwise, the caller must guarantee that the buffer is large enough to hold any individual strip of raw data.

Reads a custom directory from the arbitrary offset within file/stream.

Reads the contents of the next TIFF directory in an open TIFF file/stream and makes it the current directory.

Directories are read sequentially.

Applications only need to call ReadDirectory to read multiple subfiles in a single TIFF file/stream - the first directory in a file/stream is automatically read when Open(string, string) or ClientOpen(string, string, object, BitMiracle.LibTiff.Classic.TiffStream) is called.

The images that have a single uncompressed strip or tile of data are automatically treated as if they were made up of multiple strips or tiles of approximately 8 kilobytes each. This operation is done only in-memory; it does not alter the contents of the file/stream. However, the construction of the "chopped strips" is visible to the application through the number of strips returned by NumberOfStrips or the number of tiles returned by NumberOfTiles.

Reads an EXIF directory from the given offset within file/stream.

Reads a strip of data from an open TIFF file/stream, decompresses it and places specified amount of decompressed bytes into the user supplied buffer.

The value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

To read a full strip of data the data buffer should typically be at least as large as the number returned by StripSize. If the -1 passed in count parameter, the whole strip will be read. You should be sure you have enough space allocated for the buffer.

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Reads a tile of data from an open TIFF file/stream, decompresses it and places specified amount of decompressed bytes into the user supplied buffer.

The value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

To read a full tile of data the data buffer should typically be at least as large as the number returned by TileSize. If the -1 passed in count parameter, the whole tile will be read. You should be sure you have enough space allocated for the buffer.

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Reads the image and decodes it into RGBA format raster.

ReadRGBAImage reads a strip- or tile-based image into memory, storing the result in the user supplied RGBA raster. The raster is assumed to be an array of width times height 32-bit entries, where width must be less than or equal to the width of the image (height may be any non-zero size). If the raster dimensions are smaller than the image, the image data is cropped to the raster bounds. If the raster height is greater than that of the image, then the image data are placed in the lower part of the raster. Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin in the lower-left hand corner. Please use O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImageOriented if you want to specify another raster origin.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

ReadRGBAImage converts non-8-bit images by scaling sample values. Palette, grayscale, bilevel, CMYK, and YCbCr images are converted to RGB transparently. Raster pixels are returned uncorrected by any colorimetry information present in the directory.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBAImage is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads the image and decodes it into RGBA format raster.

ReadRGBAImage reads a strip- or tile-based image into memory, storing the result in the user supplied RGBA raster. The raster is assumed to be an array of width times height 32-bit entries, where width must be less than or equal to the width of the image (height may be any non-zero size). If the raster dimensions are smaller than the image, the image data is cropped to the raster bounds. If the raster height is greater than that of the image, then the image data are placed in the lower part of the raster. Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin in the lower-left hand corner. Please use O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImageOriented if you want to specify another raster origin.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

ReadRGBAImage converts non-8-bit images by scaling sample values. Palette, grayscale, bilevel, CMYK, and YCbCr images are converted to RGB transparently. Raster pixels are returned uncorrected by any colorimetry information present in the directory.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBAImage is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads the image and decodes it into RGBA format raster using specified raster origin.

ReadRGBAImageOriented reads a strip- or tile-based image into memory, storing the result in the user supplied RGBA raster. The raster is assumed to be an array of width times height 32-bit entries, where width must be less than or equal to the width of the image (height may be any non-zero size). If the raster dimensions are smaller than the image, the image data is cropped to the raster bounds. If the raster height is greater than that of the image, then the image data placement depends on orientation. Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin specified by orientation parameter.

When ReadRGBAImageOriented is used with Orientation.BOTLEFT for the orientation the produced result is the same as retuned by O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImage.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

ReadRGBAImageOriented converts non-8-bit images by scaling sample values. Palette, grayscale, bilevel, CMYK, and YCbCr images are converted to RGB transparently. Raster pixels are returned uncorrected by any colorimetry information present in the directory.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBAImageOriented is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads the image and decodes it into RGBA format raster using specified raster origin.

ReadRGBAImageOriented reads a strip- or tile-based image into memory, storing the result in the user supplied RGBA raster. The raster is assumed to be an array of width times height 32-bit entries, where width must be less than or equal to the width of the image (height may be any non-zero size). If the raster dimensions are smaller than the image, the image data is cropped to the raster bounds. If the raster height is greater than that of the image, then the image data placement depends on orientation. Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin specified by orientation parameter.

When ReadRGBAImageOriented is used with Orientation.BOTLEFT for the orientation the produced result is the same as retuned by O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImage.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

ReadRGBAImageOriented converts non-8-bit images by scaling sample values. Palette, grayscale, bilevel, CMYK, and YCbCr images are converted to RGB transparently. Raster pixels are returned uncorrected by any colorimetry information present in the directory.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBAImageOriented is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads a whole strip of a strip-based image, decodes it and converts it to RGBA format.

ReadRGBAStrip reads a single strip of a strip-based image into memory, storing the result in the user supplied RGBA raster. If specified strip is the last strip, then it will only contain the portion of the strip that is actually within the image space. The raster is assumed to be an array of width times rowsperstrip 32-bit entries, where width is the width of the image (TiffTag.IMAGEWIDTH) and rowsperstrip is the maximum lines in a strip (TiffTag.ROWSPERSTRIP).

The row value should be the row of the first row in the strip (strip * rowsperstrip, zero based).

Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin in the lower-left hand corner of the strip. That is bottom to top organization. When reading a partial last strip in the file the last line of the image will begin at the beginning of the buffer.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

See TiffRgbaImage for more details on how various image types are converted to RGBA values.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBAStrip's main advantage over the similar O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImage function is that for large images a single buffer capable of holding the whole image doesn't need to be allocated, only enough for one strip. The ReadRGBATile function does a similar operation for tiled images.

ReadRGBAStrip is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads a whole tile of a tile-based image, decodes it and converts it to RGBA format.

ReadRGBATile reads a single tile of a tile-based image into memory, storing the result in the user supplied RGBA raster. The raster is assumed to be an array of width times length 32-bit entries, where width is the width of the tile (TiffTag.TILEWIDTH) and length is the height of a tile (TiffTag.TILELENGTH).

The col and row values are the offsets from the top left corner of the image to the top left corner of the tile to be read. They must be an exact multiple of the tile width and length.

Note that the raster is assumed to be organized such that the pixel at location (x, y) is raster[y * width + x]; with the raster origin in the lower-left hand corner of the tile. That is bottom to top organization. Edge tiles which partly fall off the image will be filled out with appropriate zeroed areas.

Raster pixels are 8-bit packed red, green, blue, alpha samples. The Tiff.GetR, Tiff.GetG, Tiff.GetB, and Tiff.GetA should be used to access individual samples. Images without Associated Alpha matting information have a constant Alpha of 1.0 (255).

See TiffRgbaImage for more details on how various image types are converted to RGBA values.

Samples must be either 1, 2, 4, 8, or 16 bits. Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. SamplesPerPixel minus ExtraSamples).

Palette image colormaps that appear to be incorrectly written as 8-bit values are automatically scaled to 16-bits.

ReadRGBATile's main advantage over the similar O:BitMiracle.LibTiff.Classic.Tiff.ReadRGBAImage function is that for large images a single buffer capable of holding the whole image doesn't need to be allocated, only enough for one tile. The ReadRGBAStrip function does a similar operation for stripped images.

ReadRGBATile is just a wrapper around the more general TiffRgbaImage facilities.

All error messages are directed to the current error handler.

Reads the undecoded contents of a strip of data from an open TIFF file/stream and places specified amount of read bytes into the user supplied buffer.

The value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

To read a full strip of data the data buffer should typically be at least as large as the number returned by RawStripSize. If the -1 passed in count parameter, the whole strip will be read. You should be sure you have enough space allocated for the buffer.

Reads the undecoded contents of a tile of data from an open TIFF file/stream and places specified amount of read bytes into the user supplied buffer.

The value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

To read a full tile of data the data buffer should typically be at least as large as the number returned by RawTileSize. If the -1 passed in count parameter, the whole tile will be read. You should be sure you have enough space allocated for the buffer.

Reads and decodes a scanline of data from an open TIFF file/stream.

ReadScanline reads the data for the specified row into the user supplied data buffer buffer. The data are returned decompressed and, in the native byte- and bit-ordering, but are otherwise packed (see further below). The buffer must be large enough to hold an entire scanline of data. Applications should call the ScanlineSize to find out the size (in bytes) of a scanline buffer. Applications should use ReadScanline(byte[], int, short) or ReadScanline(byte[], int, int, short) and specify correct sample plane if image data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE).

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the value of TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Reads and decodes a scanline of data from an open TIFF file/stream.

ReadScanline reads the data for the specified row and specified sample plane plane into the user supplied data buffer buffer. The data are returned decompressed and, in the native byte- and bit-ordering, but are otherwise packed (see further below). The buffer must be large enough to hold an entire scanline of data. Applications should call the ScanlineSize to find out the size (in bytes) of a scanline buffer. Applications may use ReadScanline(byte[], int) or specify 0 for plane parameter if image data is contiguous (i.e not organized in separate planes, TiffTag.PLANARCONFIG = PlanarConfig.CONTIG).

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the value of TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Reads and decodes a scanline of data from an open TIFF file/stream.

ReadScanline reads the data for the specified row and specified sample plane plane into the user supplied data buffer buffer. The data are returned decompressed and, in the native byte- and bit-ordering, but are otherwise packed (see further below). The buffer must be large enough to hold an entire scanline of data. Applications should call the ScanlineSize to find out the size (in bytes) of a scanline buffer. Applications may use ReadScanline(byte[], int) or specify 0 for plane parameter if image data is contiguous (i.e not organized in separate planes, TiffTag.PLANARCONFIG = PlanarConfig.CONTIG).

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the value of TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Reads and decodes a tile of data from an open TIFF file/stream.

The tile to read and decode is selected by the (x, y, z, plane) coordinates (i.e. ReadTile returns the data for the tile containing the specified coordinates. The data placed in buffer are returned decompressed and, typically, in the native byte- and bit-ordering, but are otherwise packed (see further below). The buffer must be large enough to hold an entire tile of data. Applications should call the TileSize to find out the size (in bytes) of a tile buffer. The x and y parameters are always used by ReadTile. The z parameter is used if the image is deeper than 1 slice (a value of TiffTag.IMAGEDEPTH > 1). In other cases the value of z is ignored. The plane parameter is used only if data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). In other cases the value of plane is ignored.

The library attempts to hide bit- and byte-ordering differences between the image and the native machine by converting data to the native machine order. Bit reversal is done if the value of TiffTag.FILLORDER tag is opposite to the native machine bit order. 16- and 32-bit samples are automatically byte-swapped if the file was written with a byte order opposite to the native machine byte order.

Allocates new byte array of specified size and copies data from the existing to the new array.

Allocates new integer array of specified size and copies data from the existing to the new array.

Size of the array is in elements, not bytes.

Adds specified codec to a list of registered codec.

This method can be used to augment or override the set of codecs available to an application. If the codec is for a scheme that already has a registered codec then it is overridden and any images with data encoded with this compression scheme will be decoded using the supplied codec.

Replaces specified number of bytes in buffer with the equivalent bit-reversed bytes.

This operation is performed with a lookup table, which can be retrieved using the GetBitRevTable method.

Replaces specified number of bytes in buffer with the equivalent bit-reversed bytes starting at specified offset.

This operation is performed with a lookup table, which can be retrieved using the GetBitRevTable method.

Rewrites the contents of the current directory to the file and setup to create a new subfile (page) in the same file.

The RewriteDirectory operates similarly to WriteDirectory, but can be called with directories previously read or written that already have an established location in the file. It will rewrite the directory, but instead of place it at it's old location (as WriteDirectory would) it will place them at the end of the file, correcting the pointer from the preceeding directory or file header to point to it's new location. This is particularly important in cases where the size of the directory and pointed to data has grown, so it won’t fit in the space available at the old location. Note that this will result in the loss of the previously used directory space.

Calculates the size in bytes of a row of data as it would be returned in a call to O:BitMiracle.LibTiff.Classic.Tiff.ReadScanline, or as it would be expected in a call to O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline.

ScanlineSize calculates size for one sample plane only. Please use RasterScanlineSize if you want to get size in bytes of a complete decoded and packed raster scanline.

Associates extra information with this Tiff.

If there is already an extra information with the name specified by name it will be replaced by the information specified by data.

Asscociates a custom data with this Tiff.

Sets the directory with specified number as the current directory.

SetDirectory changes the current directory and reads its contents with ReadDirectory.

Sets an instance of the TiffErrorHandler class as custom library-wide error and warning handler.

Sets the value(s) of a tag in a TIFF file/stream open for writing.

SetField sets the value of a tag or pseudo-tag in the current directory associated with the open TIFF file/stream. To set the value of a field the file/stream must have been previously opened for writing with Open(string, string) or ClientOpen(string, string, object, BitMiracle.LibTiff.Classic.TiffStream); pseudo-tags can be set whether the file was opened for reading or writing. The tag is identified by tag. The type and number of values in value is dependent on the tag being set. You may want to consult "Well-known tags and their value(s) data types" to become familiar with exact data types and calling conventions required for each tag supported by the library.

A pseudo-tag is a parameter that is used to control the operation of the library but whose value is not read or written to the underlying file.

The field will be written to the file when/if the directory structure is updated.

Sets the new ID string for this Tiff.

Please note, that name is an arbitrary string used as ID for this Tiff. It's not required to be a file name or anything meaningful at all.

Sets the new mode for the underlying file or stream.

Sets the directory at specified file/stream offset as the current directory.

SetSubDirectory acts like SetDirectory, except the directory is specified as a file offset instead of an index; this is required for accessing subdirectories linked through a SubIFD tag (e.g. thumbnail images).

Sets the tag extender method.

Extender method is called upon creation of each instance of Tiff object.

Sets the new tag methods to use.

Sets the current write offset.

This should only be used to set the offset to a known previous location (very carefully), or to 0 so that the next write gets appended to the end of the file.

Setups the strips.

Converts array of 16-bit values into array of bytes.

Computes the number of bytes in a row-aligned strip.

StripSize returns the equivalent size for a strip of data as it would be returned in a call to ReadEncodedStrip or as it would be expected in a call to O:BitMiracle.LibTiff.Classic.Tiff.WriteEncodedStrip.

If the value of the field corresponding to TiffTag.ROWSPERSTRIP is larger than the recorded TiffTag.IMAGELENGTH, then the strip size is truncated to reflect the actual space required to hold the strip.

Swaps the bytes in specified number of values in the array of double-precision floating-point numbers.

Swaps the bytes in specified number of values in the array of double-precision floating-point numbers starting at specified offset.

Swaps the bytes in specified number of values in the array of 32-bit items.

Swaps the bytes in specified number of values in the array of 32-bit items starting at specified offset.

Swaps the bytes in specified number of values in the array of 16-bit items.

Swaps the bytes in specified number of values in the array of 16-bit items starting at specified offset.

Swaps the bytes in specified number of values in the array of triples (24-bit items).

Swaps the bytes in specified number of values in the array of triples (24-bit items) starting at specified offset.

Swaps the bytes in a single double-precision floating-point number.

Swaps the bytes in a single 32-bit item.

Swaps the bytes in a single 16-bit item.

Compute the number of bytes in each row of a tile.

Compute the number of bytes in a row-aligned tile.

TileSize returns the equivalent size for a tile of data as it would be returned in a call to ReadTile or as it would be expected in a call to O:BitMiracle.LibTiff.Classic.Tiff.WriteTile.

Removes specified codec from a list of registered codecs.

Unlinks the specified directory from the directory chain.

UnlinkDirectory does not removes directory bytes from the file/stream. It only makes them unused.

Computes the number of bytes in a row-aligned strip with specified number of rows.

Computes the number of bytes in a row-aligned tile with specified number of rows.

Invokes the library-wide warning handling methods to (normally) write a warning message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which a warning is detected.

Applications that desire to capture control in the event of a warning should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide warning handling methods to (normally) write a warning message to the Console.Error.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which a warning is detected.

Applications that desire to capture control in the event of a warning should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide warning handling methods to (normally) write a warning message to the Console.Error and passes client data to the warning handler.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which a warning is detected.

The clientData parameter can be anything you want. It will be passed unchanged to the warning handler. Default warning handler does not use it. Only custom warning handlers may make use of it.

Applications that desire to capture control in the event of a warning should use SetErrorHandler to override the default error and warning handler.

Invokes the library-wide warning handling methods to (normally) write a warning message to the Console.Error and passes client data to the warning handler.

The format is a composite format string that uses the same format as O:System.String.Format method. The method parameter, if not null, is printed before the message; it typically is used to identify the method in which a warning is detected.

The clientData parameter can be anything you want. It will be passed unchanged to the warning handler. Default warning handler does not use it. Only custom warning handlers may make use of it.

Applications that desire to capture control in the event of a warning should use SetErrorHandler to override the default error and warning handler.

Sets up the data buffer used to write raw (encoded) data to a file.

This method is provided for client-control of the I/O buffers used by the library. Applications need never use this method; it's provided only for "intelligent clients" that wish to optimize memory usage and/or eliminate potential copy operations that can occur when working with images that have data stored without compression.

If the size is -1 then the buffer size is selected to hold a complete tile or strip, or at least 8 kilobytes, whichever is greater. If the buffer is null, then a buffer of appropriate size is allocated by the library.

Verifies that file/stream is writable and that the directory information is setup properly.

Writes the contents of the current directory to the file and setup to create a new subfile (page) in the same file.

Applications only need to call WriteDirectory when writing multiple subfiles (pages) to a single TIFF file. WriteDirectory is automatically called by Close and Flush to write a modified directory if the file is open for writing.

Encodes and writes a strip of data to an open TIFF file/stream.

WriteEncodedStrip encodes count bytes of raw data from buffer and append the result to the specified strip; replacing any previously written data. Note that the value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

If there is no space for the strip, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the strip (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8.

Encodes and writes a strip of data to an open TIFF file/stream.

WriteEncodedStrip encodes count bytes of raw data from buffer and append the result to the specified strip; replacing any previously written data. Note that the value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

If there is no space for the strip, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the strip (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8.

Encodes and writes a tile of data to an open TIFF file/stream.

WriteEncodedTile encodes count bytes of raw data from buffer and append the result to the end of the specified tile. Note that the value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

There must be space for the data. The function clamps individual writes to a tile to the tile size, but does not (and can not) check that multiple writes to the same tile were performed.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteEncodedTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8.

Encodes and writes a tile of data to an open TIFF file/stream.

WriteEncodedTile encodes count bytes of raw data from buffer and append the result to the end of the specified tile. Note that the value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

There must be space for the data. The function clamps individual writes to a tile to the tile size, but does not (and can not) check that multiple writes to the same tile were performed.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteEncodedTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8.

Writes a strip of raw data to an open TIFF file/stream.

WriteRawStrip appends count bytes of raw data from buffer to the specified strip; replacing any previously written data. Note that the value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

If there is no space for the strip, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the strip (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

Writes a strip of raw data to an open TIFF file/stream.

WriteRawStrip appends count bytes of raw data from buffer to the specified strip; replacing any previously written data. Note that the value of strip is a "raw strip number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeStrip automatically does this when converting an (row, plane) to a strip index.

If there is no space for the strip, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the strip (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

Writes a tile of raw data to an open TIFF file/stream.

WriteRawTile appends count bytes of raw data to the end of the specified tile. Note that the value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

There must be space for the data. The function clamps individual writes to a tile to the tile size, but does not (and can not) check that multiple writes to the same tile were performed.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteRawTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

Writes a tile of raw data to an open TIFF file/stream.

WriteRawTile appends count bytes of raw data to the end of the specified tile. Note that the value of tile is a "raw tile number". That is, the caller must take into account whether or not the data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). ComputeTile automatically does this when converting an (x, y, z, plane) coordinate quadruple to a tile number.

There must be space for the data. The function clamps individual writes to a tile to the tile size, but does not (and can not) check that multiple writes to the same tile were performed.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteRawTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

Encodes and writes a scanline of data to an open TIFF file/stream.

WriteScanline encodes and writes to a file at the specified row. Applications should use WriteScanline(byte[], int, short) or WriteScanline(byte[], int, int, short) and specify correct sample plane parameter if image data in a file/stream is organized in separate planes (i.e TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE).

The data are assumed to be uncompressed and in the native bit- and byte-order of the host machine. The data written to the file is compressed according to the compression scheme of the current TIFF directory (see further below). If the current scanline is past the end of the current subfile, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the scanline (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8. The library attempts to hide bit-ordering differences between the image and the native machine by converting data from the native machine order.

Once data are written to a file/stream for the current directory, the values of certain tags may not be altered; see "Well-known tags and their value(s) data types" for more information.

It is not possible to write scanlines to a file/stream that uses a tiled organization. The IsTiled can be used to determine if the file/stream is organized as tiles or strips.

Encodes and writes a scanline of data to an open TIFF file/stream.

WriteScanline encodes and writes to a file at the specified row and specified sample plane plane. Applications may use WriteScanline(byte[], int) or specify 0 for plane parameter if image data in a file/stream is contiguous (i.e not organized in separate planes, TiffTag.PLANARCONFIG = PlanarConfig.CONTIG).

The data are assumed to be uncompressed and in the native bit- and byte-order of the host machine. The data written to the file is compressed according to the compression scheme of the current TIFF directory (see further below). If the current scanline is past the end of the current subfile, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the scanline (except for TiffTag.PLANARCONFIG = PlanarConfig.CONTIG, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8. The library attempts to hide bit-ordering differences between the image and the native machine by converting data from the native machine order.

Once data are written to a file/stream for the current directory, the values of certain tags may not be altered; see "Well-known tags and their value(s) data types" for more information.

It is not possible to write scanlines to a file/stream that uses a tiled organization. The IsTiled can be used to determine if the file/stream is organized as tiles or strips.

Encodes and writes a scanline of data to an open TIFF file/stream.

WriteScanline encodes and writes to a file at the specified row and specified sample plane plane. Applications may use WriteScanline(byte[], int) or specify 0 for plane parameter if image data in a file/stream is contiguous (i.e not organized in separate planes, TiffTag.PLANARCONFIG = PlanarConfig.CONTIG).

The data are assumed to be uncompressed and in the native bit- and byte-order of the host machine. The data written to the file is compressed according to the compression scheme of the current TIFF directory (see further below). If the current scanline is past the end of the current subfile, the value of TiffTag.IMAGELENGTH tag is automatically increased to include the scanline (except for TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE, where the TiffTag.IMAGELENGTH tag cannot be changed once the first data are written). If the TiffTag.IMAGELENGTH is increased, the values of TiffTag.STRIPOFFSETS and TiffTag.STRIPBYTECOUNTS tags are similarly enlarged to reflect data written past the previous end of image.

The library writes encoded data using the native machine byte order. Correctly implemented TIFF readers are expected to do any necessary byte-swapping to correctly process image data with value of TiffTag.BITSPERSAMPLE tag greater than 8. The library attempts to hide bit-ordering differences between the image and the native machine by converting data from the native machine order.

Once data are written to a file/stream for the current directory, the values of certain tags may not be altered; see "Well-known tags and their value(s) data types" for more information.

It is not possible to write scanlines to a file/stream that uses a tiled organization. The IsTiled can be used to determine if the file/stream is organized as tiles or strips.

Encodes and writes a tile of data to an open TIFF file/stream.

The tile to place encoded data is selected by the (x, y, z, plane) coordinates (i.e. WriteTile writes data to the tile containing the specified coordinates. WriteTile (potentially) encodes the data buffer and writes it to open file/stream. The buffer must contain an entire tile of data. Applications should call the TileSize to find out the size (in bytes) of a tile buffer. The x and y parameters are always used by WriteTile. The z parameter is used if the image is deeper than 1 slice (a value of TiffTag.IMAGEDEPTH > 1). In other cases the value of z is ignored. The plane parameter is used only if data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). In other cases the value of plane is ignored.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

Encodes and writes a tile of data to an open TIFF file/stream.

The tile to place encoded data is selected by the (x, y, z, plane) coordinates (i.e. WriteTile writes data to the tile containing the specified coordinates. WriteTile (potentially) encodes the data buffer and writes it to open file/stream. The buffer must contain an entire tile of data. Applications should call the TileSize to find out the size (in bytes) of a tile buffer. The x and y parameters are always used by WriteTile. The z parameter is used if the image is deeper than 1 slice (a value of TiffTag.IMAGEDEPTH > 1). In other cases the value of z is ignored. The plane parameter is used only if data are organized in separate planes (TiffTag.PLANARCONFIG = PlanarConfig.SEPARATE). In other cases the value of plane is ignored.

A correct value for the TiffTag.IMAGELENGTH tag must be setup before writing; WriteTile does not support automatically growing the image on each write (as O:BitMiracle.LibTiff.Classic.Tiff.WriteScanline does).

Appends the data to the specified strip.

Checks the directory offset against the list of already seen directory offsets.

This is a trick to prevent IFD looping. The one can create TIFF file with looped directory pointers. We will maintain a list of already seen directories and check every IFD offset against that list.

Replace a single strip (tile) of uncompressed data with multiple strips (tiles), each approximately 8Kbytes.

This is useful for dealing with large images or for dealing with machines with a limited amount of memory.

Fetches an array of ANY values.

The actual values are returned as doubles which should be able hold all the types. Note in particular that we assume that the double return value vector is large enough to read in any fundamental type. We use that vector as a buffer to read in the base type vector and then convert it in place to double (from end to front of course).

Fetches an array of BYTE or SBYTE values.

Fetches a contiguous directory item.

Reads IFD structure from the specified offset.

Fetches an array of DOUBLE values.

Fetch a single floating point value from the offset field and return it as a native float.

Fetches an array of FLOAT values.

Fetches an array of LONG or SLONG values.

Fetches a tag that is not handled by special case code.

Fetches samples/pixel ANY values for the specified tag and verify that all values are the same.

Fetches samples/pixel long values for the specified tag and verify that all values are the same.

Fetches samples/pixel short values for the specified tag and verify that all values are the same.

Fetch an array of RATIONAL or SRATIONAL values.

Fetches and sets the RefBlackWhite tag.

Fetch an array of SHORT or SSHORT values.

Fetches an ASCII item from the file.

Fetches a set of offsets or lengths.

While this routine says "strips", in fact it's also used for tiles.

Read the specified strip and setup for decoding. The data buffer is expanded, as necessary, to hold the strip's data.

Read the specified tile and setup for decoding. The data buffer is expanded, as necessary, to hold the tile's data.

Link the current directory into the directory chain for the file.

Compression schemes statically built into the library.

Setups a SHORT directory entry

Setups a directory entry with either a SHORT or LONG type according to the value.

Set state to appear as if a strip has just been read in.

Writes an array of "type" values for a specified tag (i.e. this is a tag which is allowed to have different types, e.g. SMaxSampleType). Internally the data values are represented as double since a double can hold any of the TIFF tag types (yes, this should really be an abstract type tany_t for portability). The data is converted into the specified type in a temporary buffer and then handed off to the appropriate array writer.

Write/copy data associated with an ASCII or opaque tag value.

Writes a contiguous directory item.

Writes the contents of the current directory to the specified file.

This routine doesn't handle overwriting a directory with auxiliary storage that's been changed.

Setup a directory entry of an array of LONG or SLONG and write the associated indirect values.

Writes tags that are not special cased.

Setup a directory entry of an array of RATIONAL or SRATIONAL and write the associated indirect values.

Setup a directory entry of an array of SHORT or SSHORT and write the associated indirect values.

Setup a directory entry for an NxM table of shorts, where M is known to be 2**bitspersample, and write the associated indirect data.