This class writes the file format wrapper that may or may not exist around
/// a valid JPEG 2000 codestream. This class writes the simple possible legal
/// fileformat
@@ -61,28 +62,28 @@ namespace CSJ2K.j2k.fileformat.writer
/// The file from which to read the codestream and write file
private BEBufferedRandomAccessFile fi;
- /// The name of the file from which to read the codestream and to write
+ /// The stream from which to read the codestream and to write
/// the JP2 file
///
- private System.String filename;
+ private Stream stream;
/// Image height
- private int height;
+ private readonly int height;
/// Image width
- private int width;
+ private readonly int width;
/// Number of components
- private int nc;
+ private readonly int nc;
/// Bits per component
- private int[] bpc;
+ private readonly int[] bpc;
/// Flag indicating whether number of bits per component varies
- private bool bpcVaries;
+ private readonly bool bpcVaries;
/// Length of codestream
- private int clength;
+ private readonly int clength;
/// Length of Colour Specification Box
private const int CSB_LENGTH = 15;
@@ -102,7 +103,7 @@ namespace CSJ2K.j2k.fileformat.writer
/// information necessary about a codestream to generate a legal JP2 file
///
///
- /// The name of the file that is to be made a JP2 file
+ /// The stream that is to be made a JP2 file
///
///
/// The height of the image
@@ -120,13 +121,13 @@ namespace CSJ2K.j2k.fileformat.writer
/// Length of codestream
///
///
- public FileFormatWriter(System.String filename, int height, int width, int nc, int[] bpc, int clength)
+ public FileFormatWriter(Stream stream, int height, int width, int nc, int[] bpc, int clength)
{
this.height = height;
this.width = width;
this.nc = nc;
this.bpc = bpc;
- this.filename = filename;
+ this.stream = stream;
this.clength = clength;
bpcVaries = false;
@@ -157,7 +158,7 @@ namespace CSJ2K.j2k.fileformat.writer
try
{
// Read and buffer the codestream
- fi = new BEBufferedRandomAccessFile(filename, "rw+");
+ fi = new BEBufferedRandomAccessFile(stream, false);
codestream = new byte[clength];
fi.readFully(codestream, 0, clength);
@@ -180,7 +181,7 @@ namespace CSJ2K.j2k.fileformat.writer
}
catch (System.Exception e)
{
- throw new System.ApplicationException("Error while writing JP2 file format(2): " + e.Message + "\n" + e.StackTrace);
+ throw new System.InvalidOperationException("Error while writing JP2 file format(2): " + e.Message + "\n" + e.StackTrace);
}
if (bpcVaries)
return 12 + FTB_LENGTH + 8 + IHB_LENGTH + CSB_LENGTH + BPC_LENGTH + nc + 8;
diff --git a/CSJ2K/j2k/image/BlkImgDataSrc.cs b/CSJ2K/j2k/image/BlkImgDataSrc.cs
index 353249fe..09ea0b22 100644
--- a/CSJ2K/j2k/image/BlkImgDataSrc.cs
+++ b/CSJ2K/j2k/image/BlkImgDataSrc.cs
@@ -41,139 +41,160 @@
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
using System;
+
namespace CSJ2K.j2k.image
{
-
- /// This interface defines the methods to transfer image data in blocks,
- /// without following any particular order (random access). This interface does
- /// not define the methods to access the image characteristics, such as width,
- /// height, number of components, tiles, etc., or to change the current
- /// tile. That is provided by other interfaces such as ImgData.
- ///
- /// This interface has the notion of a current tile. All data, coordinates
- /// and dimensions are always relative to the current tile. If there is only
- /// one tile then it is equivalent as having no tiles.
- ///
- ///
A block of requested data may never cross tile boundaries. This should
- /// be enforced by the implementing class, or the source of image data.
- ///
- ///
This interface defines the methods that can be used to retrieve image
- /// data. Implementing classes need not buffer all the image data, they can ask
- /// their source to load the data they need.
- ///
- ///
- ///
- ///
- ///
- public interface BlkImgDataSrc:ImgData
- {
-
- /// Returns the position of the fixed point in the specified component, or
- /// equivalently the number of fractional bits. This is the position of the
- /// least significant integral (i.e. non-fractional) bit, which is
- /// equivalent to the number of fractional bits. For instance, for
- /// fixed-point values with 2 fractional bits, 2 is returned. For
- /// floating-point data this value does not apply and 0 should be
- /// returned. Position 0 is the position of the least significant bit in
- /// the data.
- ///
- ///
- /// The index of the component.
- ///
- ///
- /// The position of the fixed-point, which is the same as the
- /// number of fractional bits. For floating-point data 0 is returned.
- ///
- ///
- int getFixedPoint(int c);
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a reference to the internal data, if any, instead of as a
- /// copy, therefore the returned data should not be modified.
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' and
- /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
- ///
- ///
This method, in general, is more efficient than the 'getCompData()'
- /// method since it may not copy the data. However if the array of returned
- /// data is to be modified by the caller then the other method is probably
- /// preferable.
- ///
- ///
If possible, the data in the returned 'DataBlk' should be the
- /// internal data itself, instead of a copy, in order to increase the data
- /// transfer efficiency. However, this depends on the particular
- /// implementation (it may be more convenient to just return a copy of the
- /// data). This is the reason why the returned data should not be modified.
- ///
- ///
If the data array in blk is null, then a new one
- /// is created if necessary. The implementation of this interface may
- /// choose to return the same array or a new one, depending on what is more
- /// efficient. Therefore, the data array in blk prior to the
- /// method call should not be considered to contain the returned data, a
- /// new array may have been created. Instead, get the array from
- /// blk after the method has returned.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. Some fields in this object are modified
- /// to return the data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- DataBlk getInternCompData(DataBlk blk, int c);
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a copy of the internal data, therefore the returned data
- /// can be modified "in place".
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' of
- /// the returned data is 0, and the 'scanw' is the same as the block's
- /// width. See the 'DataBlk' class.
- ///
- ///
This method, in general, is less efficient than the
- /// 'getInternCompData()' method since, in general, it copies the
- /// data. However if the array of returned data is to be modified by the
- /// caller then this method is preferable.
- ///
- ///
If the data array in 'blk' is 'null', then a new one is created. If
- /// the data array is not 'null' then it is reused, and it must be large
- /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
- /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. If it contains a non-null data array,
- /// then it must be large enough. If it contains a null data array a new
- /// one is created. Some fields in this object are modified to return the
- /// data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- ///
- ///
- ///
- DataBlk getCompData(DataBlk blk, int c);
- }
-}
\ No newline at end of file
+
+ /// This interface defines the methods to transfer image data in blocks,
+ /// without following any particular order (random access). This interface does
+ /// not define the methods to access the image characteristics, such as width,
+ /// height, number of components, tiles, etc., or to change the current
+ /// tile. That is provided by other interfaces such as ImgData.
+ ///
+ /// This interface has the notion of a current tile. All data, coordinates
+ /// and dimensions are always relative to the current tile. If there is only
+ /// one tile then it is equivalent as having no tiles.
+ ///
+ ///
A block of requested data may never cross tile boundaries. This should
+ /// be enforced by the implementing class, or the source of image data.
+ ///
+ ///
This interface defines the methods that can be used to retrieve image
+ /// data. Implementing classes need not buffer all the image data, they can ask
+ /// their source to load the data they need.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public interface BlkImgDataSrc : ImgData
+ {
+
+ /// Returns the position of the fixed point in the specified component, or
+ /// equivalently the number of fractional bits. This is the position of the
+ /// least significant integral (i.e. non-fractional) bit, which is
+ /// equivalent to the number of fractional bits. For instance, for
+ /// fixed-point values with 2 fractional bits, 2 is returned. For
+ /// floating-point data this value does not apply and 0 should be
+ /// returned. Position 0 is the position of the least significant bit in
+ /// the data.
+ ///
+ ///
+ /// The index of the component.
+ ///
+ ///
+ /// The position of the fixed-point, which is the same as the
+ /// number of fractional bits. For floating-point data 0 is returned.
+ ///
+ ///
+ int getFixedPoint(int c);
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a reference to the internal data, if any, instead of as a
+ /// copy, therefore the returned data should not be modified.
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' and
+ /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
+ ///
+ ///
This method, in general, is more efficient than the 'getCompData()'
+ /// method since it may not copy the data. However if the array of returned
+ /// data is to be modified by the caller then the other method is probably
+ /// preferable.
+ ///
+ ///
If possible, the data in the returned 'DataBlk' should be the
+ /// internal data itself, instead of a copy, in order to increase the data
+ /// transfer efficiency. However, this depends on the particular
+ /// implementation (it may be more convenient to just return a copy of the
+ /// data). This is the reason why the returned data should not be modified.
+ ///
+ ///
If the data array in blk is null, then a new one
+ /// is created if necessary. The implementation of this interface may
+ /// choose to return the same array or a new one, depending on what is more
+ /// efficient. Therefore, the data array in blk prior to the
+ /// method call should not be considered to contain the returned data, a
+ /// new array may have been created. Instead, get the array from
+ /// blk after the method has returned.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. Some fields in this object are modified
+ /// to return the data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ DataBlk getInternCompData(DataBlk blk, int c);
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a copy of the internal data, therefore the returned data
+ /// can be modified "in place".
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' of
+ /// the returned data is 0, and the 'scanw' is the same as the block's
+ /// width. See the 'DataBlk' class.
+ ///
+ ///
This method, in general, is less efficient than the
+ /// 'getInternCompData()' method since, in general, it copies the
+ /// data. However if the array of returned data is to be modified by the
+ /// caller then this method is preferable.
+ ///
+ ///
If the data array in 'blk' is 'null', then a new one is created. If
+ /// the data array is not 'null' then it is reused, and it must be large
+ /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
+ /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. If it contains a non-null data array,
+ /// then it must be large enough. If it contains a null data array a new
+ /// one is created. Some fields in this object are modified to return the
+ /// data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ ///
+ ///
+ ///
+ DataBlk getCompData(DataBlk blk, int c);
+
+ /// Closes the underlying file or network connection from where the
+ /// image data is being read.
+ ///
+ ///
+ /// If an I/O error occurs.
+ ///
+ void close();
+
+ /// Returns true if the data read was originally signed in the specified
+ /// component, false if not.
+ ///
+ ///
+ /// The index of the component, from 0 to C-1.
+ ///
+ ///
+ /// true if the data was originally signed, false if not.
+ ///
+ ///
+ bool isOrigSigned(int c);
+ }
+}
diff --git a/CSJ2K/j2k/image/ImgDataConverter.cs b/CSJ2K/j2k/image/ImgDataConverter.cs
index 96c8a590..037ea5e4 100644
--- a/CSJ2K/j2k/image/ImgDataConverter.cs
+++ b/CSJ2K/j2k/image/ImgDataConverter.cs
@@ -44,380 +44,417 @@
using System;
using CSJ2K.j2k.image;
using CSJ2K.j2k;
+
namespace CSJ2K.j2k.image
{
-
- /// This class is responsible of all data type conversions. It should be used,
- /// at encoder side, between Tiler and ForwardWT modules and, at decoder side,
- /// between InverseWT/CompDemixer and ImgWriter modules. The conversion is
- /// realized when a block of data is requested: if source and destination data
- /// type are the same one, it does nothing, else appropriate cast is done. All
- /// the methods of the 'ImgData' interface are implemented by the
- /// 'ImgDataAdapter' class that is the superclass of this one, so they don't
- /// need to be reimplemented by subclasses.
- ///
- ///
- public class ImgDataConverter:ImgDataAdapter, BlkImgDataSrc
- {
-
- /// The block used to request data from the source in the case that a
- /// conversion seems necessary. It can be either int or float at
- /// initialization time. It will be checked (and corrected if necessary) by
- /// the source whenever necessary
- ///
- private DataBlk srcBlk = new DataBlkInt();
-
- /// The source of image data
- private BlkImgDataSrc src;
-
- /// The number of fraction bits in the casted ints
- private int fp;
-
- /// Constructs a new ImgDataConverter object that operates on the specified
- /// source of image data.
- ///
- ///
- /// The source from where to get the data to be transformed
- ///
- ///
- /// The number of fraction bits in the casted ints
- ///
- ///
- ///
- ///
- ///
- public ImgDataConverter(BlkImgDataSrc imgSrc, int fp):base(imgSrc)
- {
- src = imgSrc;
- this.fp = fp;
- }
-
- /// Constructs a new ImgDataConverter object that operates on the specified
- /// source of image data.
- ///
- ///
- /// The source from where to get the data to be transformed
- ///
- ///
- ///
- ///
- ///
- public ImgDataConverter(BlkImgDataSrc imgSrc):base(imgSrc)
- {
- src = imgSrc;
- fp = 0;
- }
-
- /// Returns the position of the fixed point in the specified
- /// component. This is the position of the least significant integral
- /// (i.e. non-fractional) bit, which is equivalent to the number of
- /// fractional bits. For instance, for fixed-point values with 2 fractional
- /// bits, 2 is returned. For floating-point data this value does not apply
- /// and 0 should be returned. Position 0 is the position of the least
- /// significant bit in the data.
- ///
- ///
- /// The index of the component.
- ///
- ///
- /// The position of the fixed-point, which is the same as the
- /// number of fractional bits.
- ///
- ///
- public virtual int getFixedPoint(int c)
- {
- return fp;
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component, using the
- /// 'transfer type' specified in the block given as argument. The data is
- /// returned, as a copy of the internal data, therefore the returned data
- /// can be modified "in place".
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' of
- /// the returned data is 0, and the 'scanw' is the same as the block's
- /// width. See the 'DataBlk' class.
- ///
- ///
This method, in general, is less efficient than the
- /// 'getInternCompData()' method since, in general, it copies the
- /// data. However if the array of returned data is to be modified by the
- /// caller then this method is preferable.
- ///
- ///
If the data array in 'blk' is 'null', then a new one is created. If
- /// the data array is not 'null' then it is reused, and it must be large
- /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
- /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. If it contains a non-null data array,
- /// then it must be large enough. If it contains a null data array a new
- /// one is created. Some fields in this object are modified to return the
- /// data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- ///
- ///
- ///
- public virtual DataBlk getCompData(DataBlk blk, int c)
- {
- return getData(blk, c, false);
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component, using the
- /// 'transfer type' defined in the block given as argument. The data is
- /// returned, as a reference to the internal data, if any, instead of as a
- /// copy, therefore the returned data should not be modified.
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' and
- /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
- ///
- ///
If source data and expected data (blk) are using the same type,
- /// block returned without any modification. If not appropriate cast is
- /// used.
- ///
- ///
This method, in general, is more efficient than the 'getCompData()'
- /// method since it may not copy the data. However if the array of returned
- /// data is to be modified by the caller then the other method is probably
- /// preferable.
- ///
- ///
If the data array in blk is null, then a new one
- /// is created if necessary. The implementation of this interface may
- /// choose to return the same array or a new one, depending on what is more
- /// efficient. Therefore, the data array in blk prior to the
- /// method call should not be considered to contain the returned data, a
- /// new array may have been created. Instead, get the array from
- /// blk after the method has returned.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. Some fields in this object are modified
- /// to return the data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- public DataBlk getInternCompData(DataBlk blk, int c)
- {
- return getData(blk, c, true);
- }
-
- /// Implements the 'getInternCompData()' and the 'getCompData()'
- /// methods. The 'intern' flag signals which of the two methods should run
- /// as.
- ///
- ///
- /// The data block to get.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// If true behave as 'getInternCompData(). Otherwise behave
- /// as 'getCompData()'
- ///
- ///
- /// The requested data block
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- private DataBlk getData(DataBlk blk, int c, bool intern)
- {
- DataBlk reqBlk; // Reference to block used in request to source
-
- // Keep request data type
- int otype = blk.DataType;
-
- if (otype == srcBlk.DataType)
- {
- // Probably requested type is same as source type
- reqBlk = blk;
- }
- else
- {
- // Probably requested type is not the same as source type
- reqBlk = srcBlk;
- // We need to copy requested coordinates and size
- reqBlk.ulx = blk.ulx;
- reqBlk.uly = blk.uly;
- reqBlk.w = blk.w;
- reqBlk.h = blk.h;
- }
-
- // Get source data block
- if (intern)
- {
- // We can use the intern variant
- srcBlk = src.getInternCompData(reqBlk, c);
- }
- else
- {
- // Do not use the intern variant. Note that this is not optimal
- // since if we are going to convert below then we could have used
- // the intern variant. But there is currently no way to know if we
- // will need to do conversion or not before getting the data.
- srcBlk = src.getCompData(reqBlk, c);
- }
-
- // Check if casting is needed
- if (srcBlk.DataType == otype)
- {
- return srcBlk;
- }
-
- int i;
- int k, kSrc, kmin;
- float mult;
- int w = srcBlk.w;
- int h = srcBlk.h;
-
- switch (otype)
- {
-
- case DataBlk.TYPE_FLOAT: // Cast INT -> FLOAT
-
- float[] farr;
- int[] srcIArr;
-
- // Get data array from resulting blk
- farr = (float[]) blk.Data;
- if (farr == null || farr.Length < w * h)
- {
- farr = new float[w * h];
- blk.Data = farr;
- }
-
- blk.scanw = srcBlk.w;
- blk.offset = 0;
- blk.progressive = srcBlk.progressive;
- srcIArr = (int[]) srcBlk.Data;
-
- // Cast data from source to blk
- fp = src.getFixedPoint(c);
- if (fp != 0)
- {
- mult = 1.0f / (1 << fp);
- for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1; i >= 0; i--)
- {
- for (kmin = k - w; k > kmin; k--, kSrc--)
- {
- farr[k] = ((srcIArr[kSrc] * mult));
- }
- // Jump to geggining of next line in source
- kSrc -= (srcBlk.scanw - w);
- }
- }
- else
- {
- for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1; i >= 0; i--)
- {
- for (kmin = k - w; k > kmin; k--, kSrc--)
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- farr[k] = ((float) (srcIArr[kSrc]));
- }
- // Jump to geggining of next line in source
- kSrc -= (srcBlk.scanw - w);
- }
- }
- break; // End of cast INT-> FLOAT
-
-
- case DataBlk.TYPE_INT: // cast FLOAT -> INT
- int[] iarr;
- float[] srcFArr;
-
- // Get data array from resulting blk
- iarr = (int[]) blk.Data;
- if (iarr == null || iarr.Length < w * h)
- {
- iarr = new int[w * h];
- blk.Data = iarr;
- }
- blk.scanw = srcBlk.w;
- blk.offset = 0;
- blk.progressive = srcBlk.progressive;
- srcFArr = (float[]) srcBlk.Data;
-
- // Cast data from source to blk
- if (fp != 0)
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- mult = (float) (1 << fp);
- for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1; i >= 0; i--)
- {
- for (kmin = k - w; k > kmin; k--, kSrc--)
- {
- if (srcFArr[kSrc] > 0.0f)
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- iarr[k] = (int) (srcFArr[kSrc] * mult + 0.5f);
- }
- else
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- iarr[k] = (int) (srcFArr[kSrc] * mult - 0.5f);
- }
- }
- // Jump to geggining of next line in source
- kSrc -= (srcBlk.scanw - w);
- }
- }
- else
- {
- for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1; i >= 0; i--)
- {
- for (kmin = k - w; k > kmin; k--, kSrc--)
- {
- if (srcFArr[kSrc] > 0.0f)
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- iarr[k] = (int) (srcFArr[kSrc] + 0.5f);
- }
- else
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- iarr[k] = (int) (srcFArr[kSrc] - 0.5f);
- }
- }
- // Jump to geggining of next line in source
- kSrc -= (srcBlk.scanw - w);
- }
- }
- break; // End cast FLOAT -> INT
-
- default:
- throw new System.ArgumentException("Only integer and float data " + "are " + "supported by JJ2000");
-
- }
- return blk;
- }
- }
-}
\ No newline at end of file
+
+ /// This class is responsible of all data type conversions. It should be used,
+ /// at encoder side, between Tiler and ForwardWT modules and, at decoder side,
+ /// between InverseWT/CompDemixer and ImgWriter modules. The conversion is
+ /// realized when a block of data is requested: if source and destination data
+ /// type are the same one, it does nothing, else appropriate cast is done. All
+ /// the methods of the 'ImgData' interface are implemented by the
+ /// 'ImgDataAdapter' class that is the superclass of this one, so they don't
+ /// need to be reimplemented by subclasses.
+ ///
+ ///
+ public class ImgDataConverter : ImgDataAdapter, BlkImgDataSrc
+ {
+
+ /// The block used to request data from the source in the case that a
+ /// conversion seems necessary. It can be either int or float at
+ /// initialization time. It will be checked (and corrected if necessary) by
+ /// the source whenever necessary
+ ///
+ private DataBlk srcBlk = new DataBlkInt();
+
+ /// The source of image data
+ private BlkImgDataSrc src;
+
+ /// The number of fraction bits in the casted ints
+ private int fp;
+
+ /// Constructs a new ImgDataConverter object that operates on the specified
+ /// source of image data.
+ ///
+ ///
+ /// The source from where to get the data to be transformed
+ ///
+ ///
+ /// The number of fraction bits in the casted ints
+ ///
+ ///
+ ///
+ ///
+ ///
+ public ImgDataConverter(BlkImgDataSrc imgSrc, int fp)
+ : base(imgSrc)
+ {
+ src = imgSrc;
+ this.fp = fp;
+ }
+
+ /// Constructs a new ImgDataConverter object that operates on the specified
+ /// source of image data.
+ ///
+ ///
+ /// The source from where to get the data to be transformed
+ ///
+ ///
+ ///
+ ///
+ ///
+ public ImgDataConverter(BlkImgDataSrc imgSrc)
+ : base(imgSrc)
+ {
+ src = imgSrc;
+ fp = 0;
+ }
+
+ /// Returns the position of the fixed point in the specified
+ /// component. This is the position of the least significant integral
+ /// (i.e. non-fractional) bit, which is equivalent to the number of
+ /// fractional bits. For instance, for fixed-point values with 2 fractional
+ /// bits, 2 is returned. For floating-point data this value does not apply
+ /// and 0 should be returned. Position 0 is the position of the least
+ /// significant bit in the data.
+ ///
+ ///
+ /// The index of the component.
+ ///
+ ///
+ /// The position of the fixed-point, which is the same as the
+ /// number of fractional bits.
+ ///
+ ///
+ public virtual int getFixedPoint(int c)
+ {
+ return fp;
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component, using the
+ /// 'transfer type' specified in the block given as argument. The data is
+ /// returned, as a copy of the internal data, therefore the returned data
+ /// can be modified "in place".
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' of
+ /// the returned data is 0, and the 'scanw' is the same as the block's
+ /// width. See the 'DataBlk' class.
+ ///
+ ///
This method, in general, is less efficient than the
+ /// 'getInternCompData()' method since, in general, it copies the
+ /// data. However if the array of returned data is to be modified by the
+ /// caller then this method is preferable.
+ ///
+ ///
If the data array in 'blk' is 'null', then a new one is created. If
+ /// the data array is not 'null' then it is reused, and it must be large
+ /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
+ /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. If it contains a non-null data array,
+ /// then it must be large enough. If it contains a null data array a new
+ /// one is created. Some fields in this object are modified to return the
+ /// data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public virtual DataBlk getCompData(DataBlk blk, int c)
+ {
+ return getData(blk, c, false);
+ }
+
+ /// Closes the underlying file or network connection from where the
+ /// image data is being read.
+ ///
+ ///
+ /// If an I/O error occurs.
+ ///
+ public void close()
+ {
+ // Do nothing.
+ }
+
+ /// Returns true if the data read was originally signed in the specified
+ /// component, false if not.
+ ///
+ ///
+ /// The index of the component, from 0 to C-1.
+ ///
+ ///
+ /// true if the data was originally signed, false if not.
+ ///
+ ///
+ public bool isOrigSigned(int c)
+ {
+ return false;
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component, using the
+ /// 'transfer type' defined in the block given as argument. The data is
+ /// returned, as a reference to the internal data, if any, instead of as a
+ /// copy, therefore the returned data should not be modified.
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' and
+ /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
+ ///
+ ///
If source data and expected data (blk) are using the same type,
+ /// block returned without any modification. If not appropriate cast is
+ /// used.
+ ///
+ ///
This method, in general, is more efficient than the 'getCompData()'
+ /// method since it may not copy the data. However if the array of returned
+ /// data is to be modified by the caller then the other method is probably
+ /// preferable.
+ ///
+ ///
If the data array in blk is null, then a new one
+ /// is created if necessary. The implementation of this interface may
+ /// choose to return the same array or a new one, depending on what is more
+ /// efficient. Therefore, the data array in blk prior to the
+ /// method call should not be considered to contain the returned data, a
+ /// new array may have been created. Instead, get the array from
+ /// blk after the method has returned.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. Some fields in this object are modified
+ /// to return the data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ public DataBlk getInternCompData(DataBlk blk, int c)
+ {
+ return getData(blk, c, true);
+ }
+
+ /// Implements the 'getInternCompData()' and the 'getCompData()'
+ /// methods. The 'intern' flag signals which of the two methods should run
+ /// as.
+ ///
+ ///
+ /// The data block to get.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// If true behave as 'getInternCompData(). Otherwise behave
+ /// as 'getCompData()'
+ ///
+ ///
+ /// The requested data block
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ private DataBlk getData(DataBlk blk, int c, bool intern)
+ {
+ DataBlk reqBlk; // Reference to block used in request to source
+
+ // Keep request data type
+ int otype = blk.DataType;
+
+ if (otype == srcBlk.DataType)
+ {
+ // Probably requested type is same as source type
+ reqBlk = blk;
+ }
+ else
+ {
+ // Probably requested type is not the same as source type
+ reqBlk = srcBlk;
+ // We need to copy requested coordinates and size
+ reqBlk.ulx = blk.ulx;
+ reqBlk.uly = blk.uly;
+ reqBlk.w = blk.w;
+ reqBlk.h = blk.h;
+ }
+
+ // Get source data block
+ if (intern)
+ {
+ // We can use the intern variant
+ srcBlk = src.getInternCompData(reqBlk, c);
+ }
+ else
+ {
+ // Do not use the intern variant. Note that this is not optimal
+ // since if we are going to convert below then we could have used
+ // the intern variant. But there is currently no way to know if we
+ // will need to do conversion or not before getting the data.
+ srcBlk = src.getCompData(reqBlk, c);
+ }
+
+ // Check if casting is needed
+ if (srcBlk.DataType == otype)
+ {
+ return srcBlk;
+ }
+
+ int i;
+ int k, kSrc, kmin;
+ float mult;
+ int w = srcBlk.w;
+ int h = srcBlk.h;
+
+ switch (otype)
+ {
+
+ case DataBlk.TYPE_FLOAT: // Cast INT -> FLOAT
+
+ float[] farr;
+ int[] srcIArr;
+
+ // Get data array from resulting blk
+ farr = (float[])blk.Data;
+ if (farr == null || farr.Length < w * h)
+ {
+ farr = new float[w * h];
+ blk.Data = farr;
+ }
+
+ blk.scanw = srcBlk.w;
+ blk.offset = 0;
+ blk.progressive = srcBlk.progressive;
+ srcIArr = (int[])srcBlk.Data;
+
+ // Cast data from source to blk
+ fp = src.getFixedPoint(c);
+ if (fp != 0)
+ {
+ mult = 1.0f / (1 << fp);
+ for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1;
+ i >= 0;
+ i--)
+ {
+ for (kmin = k - w; k > kmin; k--, kSrc--)
+ {
+ farr[k] = ((srcIArr[kSrc] * mult));
+ }
+ // Jump to geggining of next line in source
+ kSrc -= (srcBlk.scanw - w);
+ }
+ }
+ else
+ {
+ for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1;
+ i >= 0;
+ i--)
+ {
+ for (kmin = k - w; k > kmin; k--, kSrc--)
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ farr[k] = ((float)(srcIArr[kSrc]));
+ }
+ // Jump to geggining of next line in source
+ kSrc -= (srcBlk.scanw - w);
+ }
+ }
+ break; // End of cast INT-> FLOAT
+
+
+ case DataBlk.TYPE_INT: // cast FLOAT -> INT
+ int[] iarr;
+ float[] srcFArr;
+
+ // Get data array from resulting blk
+ iarr = (int[])blk.Data;
+ if (iarr == null || iarr.Length < w * h)
+ {
+ iarr = new int[w * h];
+ blk.Data = iarr;
+ }
+ blk.scanw = srcBlk.w;
+ blk.offset = 0;
+ blk.progressive = srcBlk.progressive;
+ srcFArr = (float[])srcBlk.Data;
+
+ // Cast data from source to blk
+ if (fp != 0)
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ mult = (float)(1 << fp);
+ for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1;
+ i >= 0;
+ i--)
+ {
+ for (kmin = k - w; k > kmin; k--, kSrc--)
+ {
+ if (srcFArr[kSrc] > 0.0f)
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ iarr[k] = (int)(srcFArr[kSrc] * mult + 0.5f);
+ }
+ else
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ iarr[k] = (int)(srcFArr[kSrc] * mult - 0.5f);
+ }
+ }
+ // Jump to geggining of next line in source
+ kSrc -= (srcBlk.scanw - w);
+ }
+ }
+ else
+ {
+ for (i = h - 1, k = w * h - 1, kSrc = srcBlk.offset + (h - 1) * srcBlk.scanw + w - 1;
+ i >= 0;
+ i--)
+ {
+ for (kmin = k - w; k > kmin; k--, kSrc--)
+ {
+ if (srcFArr[kSrc] > 0.0f)
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ iarr[k] = (int)(srcFArr[kSrc] + 0.5f);
+ }
+ else
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ iarr[k] = (int)(srcFArr[kSrc] - 0.5f);
+ }
+ }
+ // Jump to geggining of next line in source
+ kSrc -= (srcBlk.scanw - w);
+ }
+ }
+ break; // End cast FLOAT -> INT
+
+ default:
+ throw new System.ArgumentException("Only integer and float data " + "are " + "supported by JJ2000");
+
+ }
+ return blk;
+ }
+ }
+}
diff --git a/CSJ2K/j2k/image/ImgDataJoiner.cs b/CSJ2K/j2k/image/ImgDataJoiner.cs
index df781548..4266caca 100644
--- a/CSJ2K/j2k/image/ImgDataJoiner.cs
+++ b/CSJ2K/j2k/image/ImgDataJoiner.cs
@@ -40,687 +40,718 @@
*
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
-using System;
-using CSJ2K.j2k;
+
namespace CSJ2K.j2k.image
{
-
- /// This class implements the ImgData interface and allows to obtain data from
- /// different sources. Here, one source is represented by an ImgData and a
- /// component index. The typical use of this class is when the encoder needs
- /// different components (Red, Green, Blue, alpha, ...) from different input
- /// files (i.e. from different ImgReader objects).
- ///
- /// All input ImgData must not be tiled (i.e. must have only 1 tile) and the
- /// image origin must be the canvas origin. The different inputs can have
- /// different dimensions though (this will lead to different subsampling
- /// factors for each component).
- ///
- /// The input ImgData and component index list must be defined when
- /// constructing this class and can not be modified later.
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- public class ImgDataJoiner : BlkImgDataSrc
- {
- /// Returns the overall width of the current tile in pixels. This is the
- /// tile's width without accounting for any component subsampling.
- ///
- ///
- /// The total current tile's width in pixels.
- ///
- ///
- virtual public int TileWidth
- {
- get
- {
- return w;
- }
-
- }
- /// Returns the overall height of the current tile in pixels. This is the
- /// tile's height without accounting for any component subsampling.
- ///
- ///
- /// The total current tile's height in pixels.
- ///
- ///
- virtual public int TileHeight
- {
- get
- {
- return h;
- }
-
- }
- /// Returns the nominal tiles width
- virtual public int NomTileWidth
- {
- get
- {
- return w;
- }
-
- }
- /// Returns the nominal tiles height
- virtual public int NomTileHeight
- {
- get
- {
- return h;
- }
-
- }
- /// Returns the overall width of the image in pixels. This is the image's
- /// width without accounting for any component subsampling or tiling.
- ///
- ///
- /// The total image's width in pixels.
- ///
- ///
- virtual public int ImgWidth
- {
- get
- {
- return w;
- }
-
- }
- /// Returns the overall height of the image in pixels. This is the image's
- /// height without accounting for any component subsampling or tiling.
- ///
- ///
- /// The total image's height in pixels.
- ///
- ///
- virtual public int ImgHeight
- {
- get
- {
- return h;
- }
-
- }
- /// Returns the number of components in the image.
- ///
- ///
- /// The number of components in the image.
- ///
- ///
- virtual public int NumComps
- {
- get
- {
- return nc;
- }
-
- }
- /// Returns the index of the current tile, relative to a standard scan-line
- /// order. This default implementations assumes no tiling, so 0 is always
- /// returned.
- ///
- ///
- /// The current tile's index (starts at 0).
- ///
- ///
- virtual public int TileIdx
- {
- get
- {
- return 0;
- }
-
- }
- /// Returns the horizontal tile partition offset in the reference grid
- virtual public int TilePartULX
- {
- get
- {
- return 0;
- }
-
- }
- /// Returns the vertical tile partition offset in the reference grid
- virtual public int TilePartULY
- {
- get
- {
- return 0;
- }
-
- }
- /// Returns the horizontal coordinate of the image origin, the top-left
- /// corner, in the canvas system, on the reference grid.
- ///
- ///
- /// The horizontal coordinate of the image origin in the canvas
- /// system, on the reference grid.
- ///
- ///
- virtual public int ImgULX
- {
- get
- {
- return 0;
- }
-
- }
- /// Returns the vertical coordinate of the image origin, the top-left
- /// corner, in the canvas system, on the reference grid.
- ///
- ///
- /// The vertical coordinate of the image origin in the canvas
- /// system, on the reference grid.
- ///
- ///
- virtual public int ImgULY
- {
- get
- {
- return 0;
- }
-
- }
-
- /// The width of the image
- private int w;
-
- /// The height of the image
- private int h;
-
- /// The number of components in the image
- private int nc;
-
- /// The list of input ImgData
- private BlkImgDataSrc[] imageData;
-
- /// The component index associated with each ImgData
- private int[] compIdx;
-
- /// The subsampling factor along the horizontal direction, for every
- /// component
- ///
- private int[] subsX;
-
- /// The subsampling factor along the vertical direction, for every
- /// component
- ///
- private int[] subsY;
-
- /// Class constructor. Each input BlkImgDataSrc and its component index
- /// must appear in the order wanted for the output components.
- ///
- /// Example: Reading R,G,B components from 3 PGM files.
- ///
- /// BlkImgDataSrc[] idList =
- /// {
- /// new ImgReaderPGM(new BEBufferedRandomAccessFile("R.pgm", "r")),
- /// new ImgReaderPGM(new BEBufferedRandomAccessFile("G.pgm", "r")),
- /// new ImgReaderPGM(new BEBufferedRandomAccessFile("B.pgm", "r"))
- /// };
- /// int[] compIdx = {0,0,0};
- /// ImgDataJoiner idj = new ImgDataJoiner(idList, compIdx);
- ///
- ///
- /// Of course, the 2 arrays must have the same length (This length is
- /// the number of output components). The image width and height are
- /// definded to be the maximum values of all the input ImgData.
- ///
- ///
- /// The list of input BlkImgDataSrc in an array.
- ///
- ///
- /// The component index associated with each ImgData.
- ///
- ///
- public ImgDataJoiner(BlkImgDataSrc[] imD, int[] cIdx)
- {
- int i;
- int maxW, maxH;
-
- // Initializes
- imageData = imD;
- compIdx = cIdx;
- if (imageData.Length != compIdx.Length)
- throw new System.ArgumentException("imD and cIdx must have the" + " same length");
-
- nc = imD.Length;
-
- subsX = new int[nc];
- subsY = new int[nc];
-
- // Check that no source is tiled and that the image origin is at the
- // canvas origin.
- for (i = 0; i < nc; i++)
- {
- if (imD[i].getNumTiles() != 1 || imD[i].getCompULX(cIdx[i]) != 0 || imD[i].getCompULY(cIdx[i]) != 0)
- {
- throw new System.ArgumentException("All input components must, " + "not use tiles and must " + "have " + "the origin at the canvas " + "origin");
- }
- }
-
- // Guess component subsampling factors based on the fact that the
- // ceil() operation relates the reference grid size to the component's
- // size, through the subsampling factor.
-
- // Mhhh, difficult problem. For now just assume that one of the
- // subsampling factors is always 1 and that the component width is
- // always larger than its subsampling factor, which covers most of the
- // cases. We check the correctness of the solution once found to chek
- // out hypothesis.
-
- // Look for max width and height.
- maxW = 0;
- maxH = 0;
- for (i = 0; i < nc; i++)
- {
- if (imD[i].getCompImgWidth(cIdx[i]) > maxW)
- maxW = imD[i].getCompImgWidth(cIdx[i]);
- if (imD[i].getCompImgHeight(cIdx[i]) > maxH)
- maxH = imD[i].getCompImgHeight(cIdx[i]);
- }
- // Set the image width and height as the maximum ones
- w = maxW;
- h = maxH;
-
- // Now get the sumsampling factors and check the subsampling factors,
- // just to see if above hypothesis were correct.
- for (i = 0; i < nc; i++)
- {
- // This calculation only holds if the subsampling factor is less
- // than the component width
- subsX[i] = (maxW + imD[i].getCompImgWidth(cIdx[i]) - 1) / imD[i].getCompImgWidth(cIdx[i]);
- subsY[i] = (maxH + imD[i].getCompImgHeight(cIdx[i]) - 1) / imD[i].getCompImgHeight(cIdx[i]);
- if ((maxW + subsX[i] - 1) / subsX[i] != imD[i].getCompImgWidth(cIdx[i]) || (maxH + subsY[i] - 1) / subsY[i] != imD[i].getCompImgHeight(cIdx[i]))
- {
- throw new System.ApplicationException("Can not compute component subsampling " + "factors: strange subsampling.");
- }
- }
- }
-
- /// Returns the component subsampling factor in the horizontal direction,
- /// for the specified component. This is, approximately, the ratio of
- /// dimensions between the reference grid and the component itself, see the
- /// 'ImgData' interface desription for details.
- ///
- ///
- /// The index of the component (between 0 and N-1)
- ///
- ///
- /// The horizontal subsampling factor of component 'c'
- ///
- ///
- ///
- ///
- ///
- public virtual int getCompSubsX(int c)
- {
- return subsX[c];
- }
-
- /// Returns the component subsampling factor in the vertical direction, for
- /// the specified component. This is, approximately, the ratio of
- /// dimensions between the reference grid and the component itself, see the
- /// 'ImgData' interface desription for details.
- ///
- ///
- /// The index of the component (between 0 and N-1)
- ///
- ///
- /// The vertical subsampling factor of component 'c'
- ///
- ///
- ///
- ///
- ///
- public virtual int getCompSubsY(int c)
- {
- return subsY[c];
- }
-
-
- /// Returns the width in pixels of the specified tile-component
- ///
- ///
- /// Tile index
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The width in pixels of component c in tilet.
- ///
- ///
- public virtual int getTileCompWidth(int t, int c)
- {
- return imageData[c].getTileCompWidth(t, compIdx[c]);
- }
-
- /// Returns the height in pixels of the specified tile-component.
- ///
- ///
- /// The tile index.
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The height in pixels of component c in the current
- /// tile.
- ///
- ///
- public virtual int getTileCompHeight(int t, int c)
- {
- return imageData[c].getTileCompHeight(t, compIdx[c]);
- }
-
- /// Returns the width in pixels of the specified component in the overall
- /// image.
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The width in pixels of component c in the overall
- /// image.
- ///
- ///
- public virtual int getCompImgWidth(int c)
- {
- return imageData[c].getCompImgWidth(compIdx[c]);
- }
-
- /// Returns the height in pixels of the specified component in the
- /// overall image.
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The height in pixels of component n in the overall
- /// image.
- ///
- ///
- ///
- ///
- public virtual int getCompImgHeight(int n)
- {
- return imageData[n].getCompImgHeight(compIdx[n]);
- }
-
- /// Returns the number of bits, referred to as the "range bits",
- /// corresponding to the nominal range of the data in the specified
- /// component. If this number is b then for unsigned data the
- /// nominal range is between 0 and 2^b-1, and for signed data it is between
- /// -2^(b-1) and 2^(b-1)-1. For floating point data this value is not
- /// applicable.
- ///
- ///
- /// The index of the component.
- ///
- ///
- /// The number of bits corresponding to the nominal range of the
- /// data. Fro floating-point data this value is not applicable and the
- /// return value is undefined.
- ///
- ///
- public virtual int getNomRangeBits(int c)
- {
- return imageData[c].getNomRangeBits(compIdx[c]);
- }
-
- /// Returns the position of the fixed point in the specified
- /// component. This is the position of the least significant integral
- /// (i.e. non-fractional) bit, which is equivalent to the number of
- /// fractional bits. For instance, for fixed-point values with 2 fractional
- /// bits, 2 is returned. For floating-point data this value does not apply
- /// and 0 should be returned. Position 0 is the position of the least
- /// significant bit in the data.
- ///
- ///
- /// The index of the component.
- ///
- ///
- /// The position of the fixed-point, which is the same as the
- /// number of fractional bits. For floating-point data 0 is returned.
- ///
- ///
- public virtual int getFixedPoint(int c)
- {
- return imageData[c].getFixedPoint(compIdx[c]);
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a reference to the internal data, if any, instead of as a
- /// copy, therefore the returned data should not be modified.
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' and
- /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
- ///
- ///
This method, in general, is more efficient than the 'getCompData()'
- /// method since it may not copy the data. However if the array of returned
- /// data is to be modified by the caller then the other method is probably
- /// preferable.
- ///
- ///
If the data array in blk is null, then a new one
- /// is created if necessary. The implementation of this interface may
- /// choose to return the same array or a new one, depending on what is more
- /// efficient. Therefore, the data array in blk prior to the
- /// method call should not be considered to contain the returned data, a
- /// new array may have been created. Instead, get the array from
- /// blk after the method has returned.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. Some fields in this object are modified
- /// to return the data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- public virtual DataBlk getInternCompData(DataBlk blk, int c)
- {
- return imageData[c].getInternCompData(blk, compIdx[c]);
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a copy of the internal data, therefore the returned data
- /// can be modified "in place".
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' of
- /// the returned data is 0, and the 'scanw' is the same as the block's
- /// width. See the 'DataBlk' class.
- ///
- ///
This method, in general, is less efficient than the
- /// 'getInternCompData()' method since, in general, it copies the
- /// data. However if the array of returned data is to be modified by the
- /// caller then this method is preferable.
- ///
- ///
If the data array in 'blk' is 'null', then a new one is created. If
- /// the data array is not 'null' then it is reused, and it must be large
- /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
- /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
- ///
- ///
The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final" data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. If it contains a non-null data array,
- /// then it must be large enough. If it contains a null data array a new
- /// one is created. Some fields in this object are modified to return the
- /// data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- public virtual DataBlk getCompData(DataBlk blk, int c)
- {
- return imageData[c].getCompData(blk, compIdx[c]);
- }
-
- /// Changes the current tile, given the new coordinates. An
- /// IllegalArgumentException is thrown if the coordinates do not correspond
- /// to a valid tile.
- ///
- ///
- /// The horizontal coordinate of the tile.
- ///
- ///
- /// The vertical coordinate of the new tile.
- ///
- ///
- public virtual void setTile(int x, int y)
- {
- if (x != 0 || y != 0)
- {
- throw new System.ArgumentException();
- }
- }
-
- /// Advances to the next tile, in standard scan-line order (by rows then
- /// columns). A NoNextElementException is thrown if the current tile is the
- /// last one (i.e. there is no next tile). This default implementation
- /// assumes no tiling, so NoNextElementException() is always thrown.
- ///
- ///
- public virtual void nextTile()
- {
- throw new NoNextElementException();
- }
-
- /// Returns the coordinates of the current tile. This default
- /// implementation assumes no-tiling, so (0,0) is returned.
- ///
- ///
- /// If not null this object is used to return the information. If
- /// null a new one is created and returned.
- ///
- ///
- /// The current tile's coordinates.
- ///
- ///
- public virtual Coord getTile(Coord co)
- {
- if (co != null)
- {
- co.x = 0;
- co.y = 0;
- return co;
- }
- else
- {
- return new Coord(0, 0);
- }
- }
-
- /// Returns the horizontal coordinate of the upper-left corner of the
- /// specified component in the current tile.
- ///
- ///
- /// The component index.
- ///
- ///
- public virtual int getCompULX(int c)
- {
- return 0;
- }
-
- /// Returns the vertical coordinate of the upper-left corner of the
- /// specified component in the current tile.
- ///
- ///
- /// The component index.
- ///
- ///
- public virtual int getCompULY(int c)
- {
- return 0;
- }
-
- /// Returns the number of tiles in the horizontal and vertical
- /// directions. This default implementation assumes no tiling, so (1,1) is
- /// always returned.
- ///
- ///
- /// If not null this object is used to return the information. If
- /// null a new one is created and returned.
- ///
- ///
- /// The number of tiles in the horizontal (Coord.x) and vertical
- /// (Coord.y) directions.
- ///
- ///
- public virtual Coord getNumTiles(Coord co)
- {
- if (co != null)
- {
- co.x = 1;
- co.y = 1;
- return co;
- }
- else
- {
- return new Coord(1, 1);
- }
- }
-
- /// Returns the total number of tiles in the image. This default
- /// implementation assumes no tiling, so 1 is always returned.
- ///
- ///
- /// The total number of tiles in the image.
- ///
- ///
- public virtual int getNumTiles()
- {
- return 1;
- }
-
- /// Returns a string of information about the object, more than 1 line
- /// long. The information string includes information from the several
- /// input ImgData (their toString() method are called one after the other).
- ///
- ///
- /// A string of information about the object.
- ///
- ///
- public override System.String ToString()
- {
- System.String string_Renamed = "ImgDataJoiner: WxH = " + w + "x" + h;
- for (int i = 0; i < nc; i++)
- {
- //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
- string_Renamed += ("\n- Component " + i + " " + imageData[i]);
- }
- return string_Renamed;
- }
- }
-}
\ No newline at end of file
+ using System.Collections.Generic;
+
+ using CSJ2K.j2k.image.input;
+
+ /// This class implements the ImgData interface and allows to obtain data from
+ /// different sources. Here, one source is represented by an ImgData and a
+ /// component index. The typical use of this class is when the encoder needs
+ /// different components (Red, Green, Blue, alpha, ...) from different input
+ /// files (i.e. from different ImgReader objects).
+ ///
+ /// All input ImgData must not be tiled (i.e. must have only 1 tile) and the
+ /// image origin must be the canvas origin. The different inputs can have
+ /// different dimensions though (this will lead to different subsampling
+ /// factors for each component).
+ ///
+ /// The input ImgData and component index list must be defined when
+ /// constructing this class and can not be modified later.
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public class ImgDataJoiner : BlkImgDataSrc
+ {
+ /// Returns the overall width of the current tile in pixels. This is the
+ /// tile's width without accounting for any component subsampling.
+ ///
+ ///
+ /// The total current tile's width in pixels.
+ ///
+ ///
+ virtual public int TileWidth
+ {
+ get
+ {
+ return w;
+ }
+
+ }
+ /// Returns the overall height of the current tile in pixels. This is the
+ /// tile's height without accounting for any component subsampling.
+ ///
+ ///
+ /// The total current tile's height in pixels.
+ ///
+ ///
+ virtual public int TileHeight
+ {
+ get
+ {
+ return h;
+ }
+
+ }
+ /// Returns the nominal tiles width
+ virtual public int NomTileWidth
+ {
+ get
+ {
+ return w;
+ }
+
+ }
+ /// Returns the nominal tiles height
+ virtual public int NomTileHeight
+ {
+ get
+ {
+ return h;
+ }
+
+ }
+ /// Returns the overall width of the image in pixels. This is the image's
+ /// width without accounting for any component subsampling or tiling.
+ ///
+ ///
+ /// The total image's width in pixels.
+ ///
+ ///
+ virtual public int ImgWidth
+ {
+ get
+ {
+ return w;
+ }
+
+ }
+ /// Returns the overall height of the image in pixels. This is the image's
+ /// height without accounting for any component subsampling or tiling.
+ ///
+ ///
+ /// The total image's height in pixels.
+ ///
+ ///
+ virtual public int ImgHeight
+ {
+ get
+ {
+ return h;
+ }
+
+ }
+ /// Returns the number of components in the image.
+ ///
+ ///
+ /// The number of components in the image.
+ ///
+ ///
+ virtual public int NumComps
+ {
+ get
+ {
+ return nc;
+ }
+
+ }
+ /// Returns the index of the current tile, relative to a standard scan-line
+ /// order. This default implementations assumes no tiling, so 0 is always
+ /// returned.
+ ///
+ ///
+ /// The current tile's index (starts at 0).
+ ///
+ ///
+ virtual public int TileIdx
+ {
+ get
+ {
+ return 0;
+ }
+
+ }
+ /// Returns the horizontal tile partition offset in the reference grid
+ virtual public int TilePartULX
+ {
+ get
+ {
+ return 0;
+ }
+
+ }
+ /// Returns the vertical tile partition offset in the reference grid
+ virtual public int TilePartULY
+ {
+ get
+ {
+ return 0;
+ }
+
+ }
+ /// Returns the horizontal coordinate of the image origin, the top-left
+ /// corner, in the canvas system, on the reference grid.
+ ///
+ ///
+ /// The horizontal coordinate of the image origin in the canvas
+ /// system, on the reference grid.
+ ///
+ ///
+ virtual public int ImgULX
+ {
+ get
+ {
+ return 0;
+ }
+
+ }
+ /// Returns the vertical coordinate of the image origin, the top-left
+ /// corner, in the canvas system, on the reference grid.
+ ///
+ ///
+ /// The vertical coordinate of the image origin in the canvas
+ /// system, on the reference grid.
+ ///
+ ///
+ virtual public int ImgULY
+ {
+ get
+ {
+ return 0;
+ }
+
+ }
+
+ /// The width of the image
+ private readonly int w;
+
+ /// The height of the image
+ private readonly int h;
+
+ /// The number of components in the image
+ private readonly int nc;
+
+ /// The list of input ImgData
+ private readonly IList imageData;
+
+ /// The component index associated with each ImgData
+ private readonly IList compIdx;
+
+ /// The subsampling factor along the horizontal direction, for every
+ /// component
+ ///
+ private readonly int[] subsX;
+
+ /// The subsampling factor along the vertical direction, for every
+ /// component
+ ///
+ private readonly int[] subsY;
+
+ /// Class constructor. Each input BlkImgDataSrc and its component index
+ /// must appear in the order wanted for the output components.
+ ///
+ /// Example: Reading R,G,B components from 3 PGM files.
+ ///
+ /// BlkImgDataSrc[] idList =
+ /// {
+ /// new ImgReaderPGM(new BEBufferedRandomAccessFile("R.pgm", "r")),
+ /// new ImgReaderPGM(new BEBufferedRandomAccessFile("G.pgm", "r")),
+ /// new ImgReaderPGM(new BEBufferedRandomAccessFile("B.pgm", "r"))
+ /// };
+ /// int[] compIdx = {0,0,0};
+ /// ImgDataJoiner idj = new ImgDataJoiner(idList, compIdx);
+ ///
+ ///
+ /// Of course, the 2 arrays must have the same length (This length is
+ /// the number of output components). The image width and height are
+ /// definded to be the maximum values of all the input ImgData.
+ ///
+ ///
+ /// The list of input BlkImgDataSrc in an array.
+ ///
+ ///
+ /// The component index associated with each ImgData.
+ ///
+ ///
+ public ImgDataJoiner(IList imD, IList cIdx)
+ {
+ int i;
+ int maxW, maxH;
+
+ // Initializes
+ imageData = imD;
+ compIdx = cIdx;
+ if (imageData.Count != compIdx.Count)
+ throw new System.ArgumentException("imD and cIdx must have the" + " same length");
+
+ nc = imD.Count;
+
+ subsX = new int[nc];
+ subsY = new int[nc];
+
+ // Check that no source is tiled and that the image origin is at the
+ // canvas origin.
+ for (i = 0; i < nc; i++)
+ {
+ if (imD[i].getNumTiles() != 1 || imD[i].getCompULX(cIdx[i]) != 0 || imD[i].getCompULY(cIdx[i]) != 0)
+ {
+ throw new System.ArgumentException("All input components must, " + "not use tiles and must " + "have " + "the origin at the canvas " + "origin");
+ }
+ }
+
+ // Guess component subsampling factors based on the fact that the
+ // ceil() operation relates the reference grid size to the component's
+ // size, through the subsampling factor.
+
+ // Mhhh, difficult problem. For now just assume that one of the
+ // subsampling factors is always 1 and that the component width is
+ // always larger than its subsampling factor, which covers most of the
+ // cases. We check the correctness of the solution once found to chek
+ // out hypothesis.
+
+ // Look for max width and height.
+ maxW = 0;
+ maxH = 0;
+ for (i = 0; i < nc; i++)
+ {
+ if (imD[i].getCompImgWidth(cIdx[i]) > maxW)
+ maxW = imD[i].getCompImgWidth(cIdx[i]);
+ if (imD[i].getCompImgHeight(cIdx[i]) > maxH)
+ maxH = imD[i].getCompImgHeight(cIdx[i]);
+ }
+ // Set the image width and height as the maximum ones
+ w = maxW;
+ h = maxH;
+
+ // Now get the sumsampling factors and check the subsampling factors,
+ // just to see if above hypothesis were correct.
+ for (i = 0; i < nc; i++)
+ {
+ // This calculation only holds if the subsampling factor is less
+ // than the component width
+ subsX[i] = (maxW + imD[i].getCompImgWidth(cIdx[i]) - 1) / imD[i].getCompImgWidth(cIdx[i]);
+ subsY[i] = (maxH + imD[i].getCompImgHeight(cIdx[i]) - 1) / imD[i].getCompImgHeight(cIdx[i]);
+ if ((maxW + subsX[i] - 1) / subsX[i] != imD[i].getCompImgWidth(cIdx[i]) || (maxH + subsY[i] - 1) / subsY[i] != imD[i].getCompImgHeight(cIdx[i]))
+ {
+ throw new System.InvalidOperationException("Can not compute component subsampling " + "factors: strange subsampling.");
+ }
+ }
+ }
+
+ /// Returns the component subsampling factor in the horizontal direction,
+ /// for the specified component. This is, approximately, the ratio of
+ /// dimensions between the reference grid and the component itself, see the
+ /// 'ImgData' interface desription for details.
+ ///
+ ///
+ /// The index of the component (between 0 and N-1)
+ ///
+ ///
+ /// The horizontal subsampling factor of component 'c'
+ ///
+ ///
+ ///
+ ///
+ ///
+ public virtual int getCompSubsX(int c)
+ {
+ return subsX[c];
+ }
+
+ /// Returns the component subsampling factor in the vertical direction, for
+ /// the specified component. This is, approximately, the ratio of
+ /// dimensions between the reference grid and the component itself, see the
+ /// 'ImgData' interface desription for details.
+ ///
+ ///
+ /// The index of the component (between 0 and N-1)
+ ///
+ ///
+ /// The vertical subsampling factor of component 'c'
+ ///
+ ///
+ ///
+ ///
+ ///
+ public virtual int getCompSubsY(int c)
+ {
+ return subsY[c];
+ }
+
+
+ /// Returns the width in pixels of the specified tile-component
+ ///
+ ///
+ /// Tile index
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The width in pixels of component c in tilet.
+ ///
+ ///
+ public virtual int getTileCompWidth(int t, int c)
+ {
+ return imageData[c].getTileCompWidth(t, compIdx[c]);
+ }
+
+ /// Returns the height in pixels of the specified tile-component.
+ ///
+ ///
+ /// The tile index.
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The height in pixels of component c in the current
+ /// tile.
+ ///
+ ///
+ public virtual int getTileCompHeight(int t, int c)
+ {
+ return imageData[c].getTileCompHeight(t, compIdx[c]);
+ }
+
+ /// Returns the width in pixels of the specified component in the overall
+ /// image.
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The width in pixels of component c in the overall
+ /// image.
+ ///
+ ///
+ public virtual int getCompImgWidth(int c)
+ {
+ return imageData[c].getCompImgWidth(compIdx[c]);
+ }
+
+ /// Returns the height in pixels of the specified component in the
+ /// overall image.
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The height in pixels of component n in the overall
+ /// image.
+ ///
+ ///
+ ///
+ ///
+ public virtual int getCompImgHeight(int n)
+ {
+ return imageData[n].getCompImgHeight(compIdx[n]);
+ }
+
+ /// Returns the number of bits, referred to as the "range bits",
+ /// corresponding to the nominal range of the data in the specified
+ /// component. If this number is b then for unsigned data the
+ /// nominal range is between 0 and 2^b-1, and for signed data it is between
+ /// -2^(b-1) and 2^(b-1)-1. For floating point data this value is not
+ /// applicable.
+ ///
+ ///
+ /// The index of the component.
+ ///
+ ///
+ /// The number of bits corresponding to the nominal range of the
+ /// data. Fro floating-point data this value is not applicable and the
+ /// return value is undefined.
+ ///
+ ///
+ public virtual int getNomRangeBits(int c)
+ {
+ return imageData[c].getNomRangeBits(compIdx[c]);
+ }
+
+ /// Returns the position of the fixed point in the specified
+ /// component. This is the position of the least significant integral
+ /// (i.e. non-fractional) bit, which is equivalent to the number of
+ /// fractional bits. For instance, for fixed-point values with 2 fractional
+ /// bits, 2 is returned. For floating-point data this value does not apply
+ /// and 0 should be returned. Position 0 is the position of the least
+ /// significant bit in the data.
+ ///
+ ///
+ /// The index of the component.
+ ///
+ ///
+ /// The position of the fixed-point, which is the same as the
+ /// number of fractional bits. For floating-point data 0 is returned.
+ ///
+ ///
+ public virtual int getFixedPoint(int c)
+ {
+ return imageData[c].getFixedPoint(compIdx[c]);
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a reference to the internal data, if any, instead of as a
+ /// copy, therefore the returned data should not be modified.
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' and
+ /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.
+ ///
+ ///
This method, in general, is more efficient than the 'getCompData()'
+ /// method since it may not copy the data. However if the array of returned
+ /// data is to be modified by the caller then the other method is probably
+ /// preferable.
+ ///
+ ///
If the data array in blk is null, then a new one
+ /// is created if necessary. The implementation of this interface may
+ /// choose to return the same array or a new one, depending on what is more
+ /// efficient. Therefore, the data array in blk prior to the
+ /// method call should not be considered to contain the returned data, a
+ /// new array may have been created. Instead, get the array from
+ /// blk after the method has returned.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. Some fields in this object are modified
+ /// to return the data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ public virtual DataBlk getInternCompData(DataBlk blk, int c)
+ {
+ return imageData[c].getInternCompData(blk, compIdx[c]);
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a copy of the internal data, therefore the returned data
+ /// can be modified "in place".
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' of
+ /// the returned data is 0, and the 'scanw' is the same as the block's
+ /// width. See the 'DataBlk' class.
+ ///
+ ///
This method, in general, is less efficient than the
+ /// 'getInternCompData()' method since, in general, it copies the
+ /// data. However if the array of returned data is to be modified by the
+ /// caller then this method is preferable.
+ ///
+ ///
If the data array in 'blk' is 'null', then a new one is created. If
+ /// the data array is not 'null' then it is reused, and it must be large
+ /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
+ /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
+ ///
+ ///
The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final" data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. If it contains a non-null data array,
+ /// then it must be large enough. If it contains a null data array a new
+ /// one is created. Some fields in this object are modified to return the
+ /// data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ public virtual DataBlk getCompData(DataBlk blk, int c)
+ {
+ return imageData[c].getCompData(blk, compIdx[c]);
+ }
+
+ /// Closes the underlying file or network connection from where the
+ /// image data is being read.
+ ///
+ ///
+ /// If an I/O error occurs.
+ ///
+ public void close()
+ {
+ foreach (var reader in imageData)
+ {
+ reader.close();
+ }
+ }
+
+ /// Returns true if the data read was originally signed in the specified
+ /// component, false if not.
+ ///
+ ///
+ /// The index of the component, from 0 to C-1.
+ ///
+ ///
+ /// true if the data was originally signed, false if not.
+ ///
+ ///
+ public bool isOrigSigned(int c)
+ {
+ return false;
+ }
+
+ /// Changes the current tile, given the new coordinates. An
+ /// IllegalArgumentException is thrown if the coordinates do not correspond
+ /// to a valid tile.
+ ///
+ ///
+ /// The horizontal coordinate of the tile.
+ ///
+ ///
+ /// The vertical coordinate of the new tile.
+ ///
+ ///
+ public virtual void setTile(int x, int y)
+ {
+ if (x != 0 || y != 0)
+ {
+ throw new System.ArgumentException();
+ }
+ }
+
+ /// Advances to the next tile, in standard scan-line order (by rows then
+ /// columns). A NoNextElementException is thrown if the current tile is the
+ /// last one (i.e. there is no next tile). This default implementation
+ /// assumes no tiling, so NoNextElementException() is always thrown.
+ ///
+ ///
+ public virtual void nextTile()
+ {
+ throw new NoNextElementException();
+ }
+
+ /// Returns the coordinates of the current tile. This default
+ /// implementation assumes no-tiling, so (0,0) is returned.
+ ///
+ ///
+ /// If not null this object is used to return the information. If
+ /// null a new one is created and returned.
+ ///
+ ///
+ /// The current tile's coordinates.
+ ///
+ ///
+ public virtual Coord getTile(Coord co)
+ {
+ if (co != null)
+ {
+ co.x = 0;
+ co.y = 0;
+ return co;
+ }
+ else
+ {
+ return new Coord(0, 0);
+ }
+ }
+
+ /// Returns the horizontal coordinate of the upper-left corner of the
+ /// specified component in the current tile.
+ ///
+ ///
+ /// The component index.
+ ///
+ ///
+ public virtual int getCompULX(int c)
+ {
+ return 0;
+ }
+
+ /// Returns the vertical coordinate of the upper-left corner of the
+ /// specified component in the current tile.
+ ///
+ ///
+ /// The component index.
+ ///
+ ///
+ public virtual int getCompULY(int c)
+ {
+ return 0;
+ }
+
+ /// Returns the number of tiles in the horizontal and vertical
+ /// directions. This default implementation assumes no tiling, so (1,1) is
+ /// always returned.
+ ///
+ ///
+ /// If not null this object is used to return the information. If
+ /// null a new one is created and returned.
+ ///
+ ///
+ /// The number of tiles in the horizontal (Coord.x) and vertical
+ /// (Coord.y) directions.
+ ///
+ ///
+ public virtual Coord getNumTiles(Coord co)
+ {
+ if (co != null)
+ {
+ co.x = 1;
+ co.y = 1;
+ return co;
+ }
+ else
+ {
+ return new Coord(1, 1);
+ }
+ }
+
+ /// Returns the total number of tiles in the image. This default
+ /// implementation assumes no tiling, so 1 is always returned.
+ ///
+ ///
+ /// The total number of tiles in the image.
+ ///
+ ///
+ public virtual int getNumTiles()
+ {
+ return 1;
+ }
+
+ /// Returns a string of information about the object, more than 1 line
+ /// long. The information string includes information from the several
+ /// input ImgData (their toString() method are called one after the other).
+ ///
+ ///
+ /// A string of information about the object.
+ ///
+ ///
+ public override System.String ToString()
+ {
+ System.String string_Renamed = "ImgDataJoiner: WxH = " + w + "x" + h;
+ for (int i = 0; i < nc; i++)
+ {
+ //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
+ string_Renamed += ("\n- Component " + i + " " + imageData[i]);
+ }
+ return string_Renamed;
+ }
+ }
+}
diff --git a/CSJ2K/j2k/image/Tiler.cs b/CSJ2K/j2k/image/Tiler.cs
index ec8ed229..0c0845c0 100644
--- a/CSJ2K/j2k/image/Tiler.cs
+++ b/CSJ2K/j2k/image/Tiler.cs
@@ -44,707 +44,747 @@
using System;
using CSJ2K.j2k.util;
using CSJ2K.j2k;
+
namespace CSJ2K.j2k.image
{
-
- /// This class places an image in the canvas coordinate system, tiles it, if so
- /// specified, and performs the coordinate conversions transparently. The
- /// source must be a 'BlkImgDataSrc' which is not tiled and has a the image
- /// origin at the canvas origin (i.e. it is not "canvased"), or an exception is
- /// thrown by the constructor. A tiled and "canvased" output is given through
- /// the 'BlkImgDataSrc' interface. See the 'ImgData' interface for a
- /// description of the canvas and tiling.
- ///
- /// All tiles produced are rectangular, non-overlapping and their union
- /// covers all the image. However, the tiling may not be uniform, depending on
- /// the nominal tile size, tiling origin, component subsampling and other
- /// factors. Therefore it might not be assumed that all tiles are of the same
- /// width and height.
- ///
- /// The nominal dimension of the tiles is the maximal one, in the reference
- /// grid. All the components of the image have the same number of tiles.
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- public class Tiler:ImgDataAdapter, BlkImgDataSrc
- {
- /// Returns the overall width of the current tile in pixels. This is the
- /// tile's width without accounting for any component subsampling.
- ///
- ///
- /// The total current tile width in pixels.
- ///
- ///
- override public int TileWidth
- {
- get
- {
- return tileW;
- }
-
- }
- /// Returns the overall height of the current tile in pixels. This is the
- /// tile's width without accounting for any component subsampling.
- ///
- ///
- /// The total current tile height in pixels.
- ///
- ///
- override public int TileHeight
- {
- get
- {
- return tileH;
- }
-
- }
- /// Returns the index of the current tile, relative to a standard scan-line
- /// order.
- ///
- ///
- /// The current tile's index (starts at 0).
- ///
- ///
- override public int TileIdx
- {
- get
- {
- return ty * ntX + tx;
- }
-
- }
- /// Returns the horizontal tile partition offset in the reference grid
- override public int TilePartULX
- {
- get
- {
- return xt0siz;
- }
-
- }
- /// Returns the vertical tile partition offset in the reference grid
- override public int TilePartULY
- {
- get
- {
- return yt0siz;
- }
-
- }
- /// Returns the horizontal coordinate of the image origin, the top-left
- /// corner, in the canvas system, on the reference grid.
- ///
- ///
- /// The horizontal coordinate of the image origin in the canvas
- /// system, on the reference grid.
- ///
- ///
- override public int ImgULX
- {
- get
- {
- return x0siz;
- }
-
- }
- /// Returns the vertical coordinate of the image origin, the top-left
- /// corner, in the canvas system, on the reference grid.
- ///
- ///
- /// The vertical coordinate of the image origin in the canvas
- /// system, on the reference grid.
- ///
- ///
- override public int ImgULY
- {
- get
- {
- return y0siz;
- }
-
- }
- /// Returns the nominal width of the tiles in the reference grid.
- ///
- ///
- /// The nominal tile width, in the reference grid.
- ///
- ///
- override public int NomTileWidth
- {
- get
- {
- return xtsiz;
- }
-
- }
- /// Returns the nominal width of the tiles in the reference grid.
- ///
- ///
- /// The nominal tile width, in the reference grid.
- ///
- ///
- override public int NomTileHeight
- {
- get
- {
- return ytsiz;
- }
-
- }
-
- /// The source of image data
- private BlkImgDataSrc src = null;
-
- /// Horizontal coordinate of the upper left hand reference grid point.
- private int x0siz;
-
- /// Vertical coordinate of the upper left hand reference grid point.
- private int y0siz;
-
- /// The horizontal coordinate of the tiling origin in the canvas system,
- /// on the reference grid.
- ///
- private int xt0siz;
-
- /// The vertical coordinate of the tiling origin in the canvas system, on
- /// the reference grid.
- ///
- private int yt0siz;
-
- /// The nominal width of the tiles, on the reference grid. If 0 then there
- /// is no tiling in that direction.
- ///
- private int xtsiz;
-
- /// The nominal height of the tiles, on the reference grid. If 0 then
- /// there is no tiling in that direction.
- ///
- private int ytsiz;
-
- /// The number of tiles in the horizontal direction.
- private int ntX;
-
- /// The number of tiles in the vertical direction.
- private int ntY;
-
- /// The component width in the current active tile, for each component
- private int[] compW = null;
-
- /// The component height in the current active tile, for each component
- private int[] compH = null;
-
- /// The horizontal coordinates of the upper-left corner of the components
- /// in the current tile
- ///
- private int[] tcx0 = null;
-
- /// The vertical coordinates of the upper-left corner of the components in
- /// the current tile.
- ///
- private int[] tcy0 = null;
-
- /// The horizontal index of the current tile
- private int tx;
-
- /// The vertical index of the current tile
- private int ty;
-
- /// The width of the current tile, on the reference grid.
- private int tileW;
-
- /// The height of the current tile, on the reference grid.
- private int tileH;
-
- /// Constructs a new tiler with the specified 'BlkImgDataSrc' source,
- /// image origin, tiling origin and nominal tile size.
- ///
- ///
- /// The 'BlkImgDataSrc' source from where to get the image
- /// data. It must not be tiled and the image origin must be at '(0,0)' on
- /// its canvas.
- ///
- ///
- /// The horizontal coordinate of the image origin in the canvas
- /// system, on the reference grid (i.e. the image's top-left corner in the
- /// reference grid).
- ///
- ///
- /// The vertical coordinate of the image origin in the canvas
- /// system, on the reference grid (i.e. the image's top-left corner in the
- /// reference grid).
- ///
- ///
- /// The horizontal tiling origin, in the canvas system, on the
- /// reference grid. It must satisfy 'px<=ax'.
- ///
- ///
- /// The vertical tiling origin, in the canvas system, on the
- /// reference grid. It must satisfy 'py<=ay'.
- ///
- ///
- /// The nominal tile width, on the reference grid. If 0 then
- /// there is no tiling in that direction.
- ///
- ///
- /// The nominal tile height, on the reference grid. If 0 then
- /// there is no tiling in that direction.
- ///
- ///
- /// If src is tiled or "canvased", or
- /// if the arguments do not satisfy the specified constraints.
- ///
- ///
- public Tiler(BlkImgDataSrc src, int ax, int ay, int px, int py, int nw, int nh):base(src)
- {
-
- // Initialize
- this.src = src;
- this.x0siz = ax;
- this.y0siz = ay;
- this.xt0siz = px;
- this.yt0siz = py;
- this.xtsiz = nw;
- this.ytsiz = nh;
-
- // Verify that input is not tiled
- if (src.getNumTiles() != 1)
- {
- throw new System.ArgumentException("Source is tiled");
- }
- // Verify that source is not "canvased"
- if (src.ImgULX != 0 || src.ImgULY != 0)
- {
- throw new System.ArgumentException("Source is \"canvased\"");
- }
- // Verify that arguments satisfy trivial requirements
- if (x0siz < 0 || y0siz < 0 || xt0siz < 0 || yt0siz < 0 || xtsiz < 0 || ytsiz < 0 || xt0siz > x0siz || yt0siz > y0siz)
- {
- throw new System.ArgumentException("Invalid image origin, " + "tiling origin or nominal " + "tile size");
- }
-
- // If no tiling has been specified, creates a unique tile with maximum
- // dimension.
- if (xtsiz == 0)
- xtsiz = x0siz + src.ImgWidth - xt0siz;
- if (ytsiz == 0)
- ytsiz = y0siz + src.ImgHeight - yt0siz;
-
- // Automatically adjusts xt0siz,yt0siz so that tile (0,0) always
- // overlaps with the image.
- if (x0siz - xt0siz >= xtsiz)
- {
- xt0siz += ((x0siz - xt0siz) / xtsiz) * xtsiz;
- }
- if (y0siz - yt0siz >= ytsiz)
- {
- yt0siz += ((y0siz - yt0siz) / ytsiz) * ytsiz;
- }
- if (x0siz - xt0siz >= xtsiz || y0siz - yt0siz >= ytsiz)
- {
- FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.INFO, "Automatically adjusted tiling " + "origin to equivalent one (" + xt0siz + "," + yt0siz + ") so that " + "first tile overlaps the image");
- }
-
- // Calculate the number of tiles
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- ntX = (int) System.Math.Ceiling((x0siz + src.ImgWidth) / (double) xtsiz);
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- ntY = (int) System.Math.Ceiling((y0siz + src.ImgHeight) / (double) ytsiz);
- }
-
- /// Returns the width in pixels of the specified tile-component.
- ///
- ///
- /// Tile index
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The width of specified tile-component.
- ///
- ///
- public override int getTileCompWidth(int t, int c)
- {
- if (t != TileIdx)
- {
- throw new System.ApplicationException("Asking the width of a tile-component which is " + "not in the current tile (call setTile() or " + "nextTile() methods before).");
- }
- return compW[c];
- }
-
- /// Returns the height in pixels of the specified tile-component.
- ///
- ///
- /// The tile index.
- ///
- ///
- /// The index of the component, from 0 to N-1.
- ///
- ///
- /// The height of specified tile-component.
- ///
- ///
- public override int getTileCompHeight(int t, int c)
- {
- if (t != TileIdx)
- {
- throw new System.ApplicationException("Asking the width of a tile-component which is " + "not in the current tile (call setTile() or " + "nextTile() methods before).");
- }
- return compH[c];
- }
-
- /// Returns the position of the fixed point in the specified
- /// component. This is the position of the least significant integral
- /// (i.e. non-fractional) bit, which is equivalent to the number of
- /// fractional bits. For instance, for fixed-point values with 2 fractional
- /// bits, 2 is returned. For floating-point data this value does not apply
- /// and 0 should be returned. Position 0 is the position of the least
- /// significant bit in the data.
- ///
- ///
- /// The index of the component.
- ///
- ///
- /// The position of the fixed-point, which is the same as the
- /// number of fractional bits. For floating-point data 0 is returned.
- ///
- ///
- public virtual int getFixedPoint(int c)
- {
- return src.getFixedPoint(c);
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a reference to the internal data, if any, instead of as a
- /// copy, therefore the returned data should not be modified.
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' and
- /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk'
- /// class.
- ///
- /// This method, in general, is more efficient than the 'getCompData()'
- /// method since it may not copy the data. However if the array of returned
- /// data is to be modified by the caller then the other method is probably
- /// preferable.
- ///
- /// If the data array in blk is null, then a new one
- /// is created if necessary. The implementation of this interface may
- /// choose to return the same array or a new one, depending on what is more
- /// efficient. Therefore, the data array in blk prior to the
- /// method call should not be considered to contain the returned data, a
- /// new array may have been created. Instead, get the array from
- /// blk after the method has returned.
- ///
- /// The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final"
- /// data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. Some fields in this object are modified
- /// to return the data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- public DataBlk getInternCompData(DataBlk blk, int c)
- {
- // Check that block is inside tile
- if (blk.ulx < 0 || blk.uly < 0 || blk.w > compW[c] || blk.h > compH[c])
- {
- throw new System.ArgumentException("Block is outside the tile");
- }
- // Translate to the sources coordinates
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- int incx = (int) System.Math.Ceiling(x0siz / (double) src.getCompSubsX(c));
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- int incy = (int) System.Math.Ceiling(y0siz / (double) src.getCompSubsY(c));
- blk.ulx -= incx;
- blk.uly -= incy;
- blk = src.getInternCompData(blk, c);
- // Translate back to the tiled coordinates
- blk.ulx += incx;
- blk.uly += incy;
- return blk;
- }
-
- /// Returns, in the blk argument, a block of image data containing the
- /// specifed rectangular area, in the specified component. The data is
- /// returned, as a copy of the internal data, therefore the returned data
- /// can be modified "in place".
- ///
- /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
- /// and 'h' members of the 'blk' argument, relative to the current
- /// tile. These members are not modified by this method. The 'offset' of
- /// the returned data is 0, and the 'scanw' is the same as the block's
- /// width. See the 'DataBlk' class.
- ///
- /// This method, in general, is less efficient than the
- /// 'getInternCompData()' method since, in general, it copies the
- /// data. However if the array of returned data is to be modified by the
- /// caller then this method is preferable.
- ///
- /// If the data array in 'blk' is 'null', then a new one is created. If
- /// the data array is not 'null' then it is reused, and it must be large
- /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
- /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
- ///
- /// The returned data may have its 'progressive' attribute set. In this
- /// case the returned data is only an approximation of the "final"
- /// data.
- ///
- ///
- /// Its coordinates and dimensions specify the area to return,
- /// relative to the current tile. If it contains a non-null data array,
- /// then it must be large enough. If it contains a null data array a new
- /// one is created. Some fields in this object are modified to return the
- /// data.
- ///
- ///
- /// The index of the component from which to get the data.
- ///
- ///
- /// The requested DataBlk
- ///
- ///
- ///
- ///
- ///
- public DataBlk getCompData(DataBlk blk, int c)
- {
- // Check that block is inside tile
- if (blk.ulx < 0 || blk.uly < 0 || blk.w > compW[c] || blk.h > compH[c])
- {
- throw new System.ArgumentException("Block is outside the tile");
- }
- // Translate to the source's coordinates
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- int incx = (int) System.Math.Ceiling(x0siz / (double) src.getCompSubsX(c));
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- int incy = (int) System.Math.Ceiling(y0siz / (double) src.getCompSubsY(c));
- blk.ulx -= incx;
- blk.uly -= incy;
- blk = src.getCompData(blk, c);
- // Translate back to the tiled coordinates
- blk.ulx += incx;
- blk.uly += incy;
- return blk;
- }
-
- /// Changes the current tile, given the new tile indexes. An
- /// IllegalArgumentException is thrown if the coordinates do not correspond
- /// to a valid tile.
- ///
- ///
- /// The horizontal index of the tile.
- ///
- ///
- /// The vertical index of the new tile.
- ///
- ///
- public override void setTile(int x, int y)
- {
- // Check tile indexes
- if (x < 0 || y < 0 || x >= ntX || y >= ntY)
- {
- throw new System.ArgumentException("Tile's indexes out of bounds");
- }
-
- // Set new current tile
- tx = x;
- ty = y;
- // Calculate tile origins
- int tx0 = (x != 0)?xt0siz + x * xtsiz:x0siz;
- int ty0 = (y != 0)?yt0siz + y * ytsiz:y0siz;
- int tx1 = (x != ntX - 1)?(xt0siz + (x + 1) * xtsiz):(x0siz + src.ImgWidth);
- int ty1 = (y != ntY - 1)?(yt0siz + (y + 1) * ytsiz):(y0siz + src.ImgHeight);
- // Set general variables
- tileW = tx1 - tx0;
- tileH = ty1 - ty0;
- // Set component specific variables
- int nc = src.NumComps;
- if (compW == null)
- compW = new int[nc];
- if (compH == null)
- compH = new int[nc];
- if (tcx0 == null)
- tcx0 = new int[nc];
- if (tcy0 == null)
- tcy0 = new int[nc];
- for (int i = 0; i < nc; i++)
- {
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- tcx0[i] = (int) System.Math.Ceiling(tx0 / (double) src.getCompSubsX(i));
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- tcy0[i] = (int) System.Math.Ceiling(ty0 / (double) src.getCompSubsY(i));
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- compW[i] = (int) System.Math.Ceiling(tx1 / (double) src.getCompSubsX(i)) - tcx0[i];
- //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
- compH[i] = (int) System.Math.Ceiling(ty1 / (double) src.getCompSubsY(i)) - tcy0[i];
- }
- }
-
- /// Advances to the next tile, in standard scan-line order (by rows then
- /// columns). An NoNextElementException is thrown if the current tile is
- /// the last one (i.e. there is no next tile).
- ///
- ///
- public override void nextTile()
- {
- if (tx == ntX - 1 && ty == ntY - 1)
- {
- // Already at last tile
- throw new NoNextElementException();
- }
- else if (tx < ntX - 1)
- {
- // If not at end of current tile line
- setTile(tx + 1, ty);
- }
- else
- {
- // First tile at next line
- setTile(0, ty + 1);
- }
- }
-
- /// Returns the horizontal and vertical indexes of the current tile.
- ///
- ///
- /// If not null this object is used to return the
- /// information. If null a new one is created and returned.
- ///
- ///
- /// The current tile's horizontal and vertical indexes..
- ///
- ///
- public override Coord getTile(Coord co)
- {
- if (co != null)
- {
- co.x = tx;
- co.y = ty;
- return co;
- }
- else
- {
- return new Coord(tx, ty);
- }
- }
-
- /// Returns the horizontal coordinate of the upper-left corner of the
- /// specified component in the current tile.
- ///
- ///
- /// The component index.
- ///
- ///
- public override int getCompULX(int c)
- {
- return tcx0[c];
- }
-
- /// Returns the vertical coordinate of the upper-left corner of the
- /// specified component in the current tile.
- ///
- ///
- /// The component index.
- ///
- ///
- public override int getCompULY(int c)
- {
- return tcy0[c];
- }
-
- /// Returns the number of tiles in the horizontal and vertical directions.
- ///
- ///
- /// If not null this object is used to return the information. If
- /// null a new one is created and returned.
- ///
- ///
- /// The number of tiles in the horizontal (Coord.x) and vertical
- /// (Coord.y) directions.
- ///
- ///
- public override Coord getNumTiles(Coord co)
- {
- if (co != null)
- {
- co.x = ntX;
- co.y = ntY;
- return co;
- }
- else
- {
- return new Coord(ntX, ntY);
- }
- }
-
- /// Returns the total number of tiles in the image.
- ///
- ///
- /// The total number of tiles in the image.
- ///
- ///
- public override int getNumTiles()
- {
- return ntX * ntY;
- }
-
- /// Returns the tiling origin, referred to as '(xt0siz,yt0siz)' in the
- /// codestream header (SIZ marker segment).
- ///
- ///
- /// If not null this object is used to return the information. If
- /// null a new one is created and returned.
- ///
- ///
- /// The coordinate of the tiling origin, in the canvas system, on
- /// the reference grid.
- ///
- ///
- ///
- ///
- ///
- public Coord getTilingOrigin(Coord co)
- {
- if (co != null)
- {
- co.x = xt0siz;
- co.y = yt0siz;
- return co;
- }
- else
- {
- return new Coord(xt0siz, yt0siz);
- }
- }
-
- /// Returns a String object representing Tiler's informations
- ///
- ///
- /// Tiler's infos in a string
- ///
- ///
- public override System.String ToString()
- {
- //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
- return "Tiler: source= " + src + "\n" + getNumTiles() + " tile(s), nominal width=" + xtsiz + ", nominal height=" + ytsiz;
- }
- }
-}
\ No newline at end of file
+
+ /// This class places an image in the canvas coordinate system, tiles it, if so
+ /// specified, and performs the coordinate conversions transparently. The
+ /// source must be a 'BlkImgDataSrc' which is not tiled and has a the image
+ /// origin at the canvas origin (i.e. it is not "canvased"), or an exception is
+ /// thrown by the constructor. A tiled and "canvased" output is given through
+ /// the 'BlkImgDataSrc' interface. See the 'ImgData' interface for a
+ /// description of the canvas and tiling.
+ ///
+ /// All tiles produced are rectangular, non-overlapping and their union
+ /// covers all the image. However, the tiling may not be uniform, depending on
+ /// the nominal tile size, tiling origin, component subsampling and other
+ /// factors. Therefore it might not be assumed that all tiles are of the same
+ /// width and height.
+ ///
+ /// The nominal dimension of the tiles is the maximal one, in the reference
+ /// grid. All the components of the image have the same number of tiles.
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public class Tiler : ImgDataAdapter, BlkImgDataSrc
+ {
+ /// Returns the overall width of the current tile in pixels. This is the
+ /// tile's width without accounting for any component subsampling.
+ ///
+ ///
+ /// The total current tile width in pixels.
+ ///
+ ///
+ public override int TileWidth
+ {
+ get
+ {
+ return tileW;
+ }
+
+ }
+
+ /// Returns the overall height of the current tile in pixels. This is the
+ /// tile's width without accounting for any component subsampling.
+ ///
+ ///
+ /// The total current tile height in pixels.
+ ///
+ ///
+ public override int TileHeight
+ {
+ get
+ {
+ return tileH;
+ }
+
+ }
+
+ /// Returns the index of the current tile, relative to a standard scan-line
+ /// order.
+ ///
+ ///
+ /// The current tile's index (starts at 0).
+ ///
+ ///
+ public override int TileIdx
+ {
+ get
+ {
+ return ty * ntX + tx;
+ }
+
+ }
+
+ /// Returns the horizontal tile partition offset in the reference grid
+ public override int TilePartULX
+ {
+ get
+ {
+ return xt0siz;
+ }
+
+ }
+
+ /// Returns the vertical tile partition offset in the reference grid
+ public override int TilePartULY
+ {
+ get
+ {
+ return yt0siz;
+ }
+
+ }
+
+ /// Returns the horizontal coordinate of the image origin, the top-left
+ /// corner, in the canvas system, on the reference grid.
+ ///
+ ///
+ /// The horizontal coordinate of the image origin in the canvas
+ /// system, on the reference grid.
+ ///
+ ///
+ public override int ImgULX
+ {
+ get
+ {
+ return x0siz;
+ }
+
+ }
+
+ /// Returns the vertical coordinate of the image origin, the top-left
+ /// corner, in the canvas system, on the reference grid.
+ ///
+ ///
+ /// The vertical coordinate of the image origin in the canvas
+ /// system, on the reference grid.
+ ///
+ ///
+ public override int ImgULY
+ {
+ get
+ {
+ return y0siz;
+ }
+
+ }
+
+ /// Returns the nominal width of the tiles in the reference grid.
+ ///
+ ///
+ /// The nominal tile width, in the reference grid.
+ ///
+ ///
+ public override int NomTileWidth
+ {
+ get
+ {
+ return xtsiz;
+ }
+
+ }
+
+ /// Returns the nominal width of the tiles in the reference grid.
+ ///
+ ///
+ /// The nominal tile width, in the reference grid.
+ ///
+ ///
+ public override int NomTileHeight
+ {
+ get
+ {
+ return ytsiz;
+ }
+
+ }
+
+ /// The source of image data
+ private BlkImgDataSrc src = null;
+
+ /// Horizontal coordinate of the upper left hand reference grid point.
+ private int x0siz;
+
+ /// Vertical coordinate of the upper left hand reference grid point.
+ private int y0siz;
+
+ /// The horizontal coordinate of the tiling origin in the canvas system,
+ /// on the reference grid.
+ ///
+ private int xt0siz;
+
+ /// The vertical coordinate of the tiling origin in the canvas system, on
+ /// the reference grid.
+ ///
+ private int yt0siz;
+
+ /// The nominal width of the tiles, on the reference grid. If 0 then there
+ /// is no tiling in that direction.
+ ///
+ private int xtsiz;
+
+ /// The nominal height of the tiles, on the reference grid. If 0 then
+ /// there is no tiling in that direction.
+ ///
+ private int ytsiz;
+
+ /// The number of tiles in the horizontal direction.
+ private int ntX;
+
+ /// The number of tiles in the vertical direction.
+ private int ntY;
+
+ /// The component width in the current active tile, for each component
+ private int[] compW = null;
+
+ /// The component height in the current active tile, for each component
+ private int[] compH = null;
+
+ /// The horizontal coordinates of the upper-left corner of the components
+ /// in the current tile
+ ///
+ private int[] tcx0 = null;
+
+ /// The vertical coordinates of the upper-left corner of the components in
+ /// the current tile.
+ ///
+ private int[] tcy0 = null;
+
+ /// The horizontal index of the current tile
+ private int tx;
+
+ /// The vertical index of the current tile
+ private int ty;
+
+ /// The width of the current tile, on the reference grid.
+ private int tileW;
+
+ /// The height of the current tile, on the reference grid.
+ private int tileH;
+
+ /// Constructs a new tiler with the specified 'BlkImgDataSrc' source,
+ /// image origin, tiling origin and nominal tile size.
+ ///
+ ///
+ /// The 'BlkImgDataSrc' source from where to get the image
+ /// data. It must not be tiled and the image origin must be at '(0,0)' on
+ /// its canvas.
+ ///
+ ///
+ /// The horizontal coordinate of the image origin in the canvas
+ /// system, on the reference grid (i.e. the image's top-left corner in the
+ /// reference grid).
+ ///
+ ///
+ /// The vertical coordinate of the image origin in the canvas
+ /// system, on the reference grid (i.e. the image's top-left corner in the
+ /// reference grid).
+ ///
+ ///
+ /// The horizontal tiling origin, in the canvas system, on the
+ /// reference grid. It must satisfy 'px<=ax'.
+ ///
+ ///
+ /// The vertical tiling origin, in the canvas system, on the
+ /// reference grid. It must satisfy 'py<=ay'.
+ ///
+ ///
+ /// The nominal tile width, on the reference grid. If 0 then
+ /// there is no tiling in that direction.
+ ///
+ ///
+ /// The nominal tile height, on the reference grid. If 0 then
+ /// there is no tiling in that direction.
+ ///
+ ///
+ /// If src is tiled or "canvased", or
+ /// if the arguments do not satisfy the specified constraints.
+ ///
+ ///
+ public Tiler(BlkImgDataSrc src, int ax, int ay, int px, int py, int nw, int nh)
+ : base(src)
+ {
+
+ // Initialize
+ this.src = src;
+ this.x0siz = ax;
+ this.y0siz = ay;
+ this.xt0siz = px;
+ this.yt0siz = py;
+ this.xtsiz = nw;
+ this.ytsiz = nh;
+
+ // Verify that input is not tiled
+ if (src.getNumTiles() != 1)
+ {
+ throw new System.ArgumentException("Source is tiled");
+ }
+ // Verify that source is not "canvased"
+ if (src.ImgULX != 0 || src.ImgULY != 0)
+ {
+ throw new System.ArgumentException("Source is \"canvased\"");
+ }
+ // Verify that arguments satisfy trivial requirements
+ if (x0siz < 0 || y0siz < 0 || xt0siz < 0 || yt0siz < 0 || xtsiz < 0 || ytsiz < 0 || xt0siz > x0siz
+ || yt0siz > y0siz)
+ {
+ throw new System.ArgumentException("Invalid image origin, " + "tiling origin or nominal " + "tile size");
+ }
+
+ // If no tiling has been specified, creates a unique tile with maximum
+ // dimension.
+ if (xtsiz == 0) xtsiz = x0siz + src.ImgWidth - xt0siz;
+ if (ytsiz == 0) ytsiz = y0siz + src.ImgHeight - yt0siz;
+
+ // Automatically adjusts xt0siz,yt0siz so that tile (0,0) always
+ // overlaps with the image.
+ if (x0siz - xt0siz >= xtsiz)
+ {
+ xt0siz += ((x0siz - xt0siz) / xtsiz) * xtsiz;
+ }
+ if (y0siz - yt0siz >= ytsiz)
+ {
+ yt0siz += ((y0siz - yt0siz) / ytsiz) * ytsiz;
+ }
+ if (x0siz - xt0siz >= xtsiz || y0siz - yt0siz >= ytsiz)
+ {
+ FacilityManager.getMsgLogger()
+ .printmsg(
+ CSJ2K.j2k.util.MsgLogger_Fields.INFO,
+ "Automatically adjusted tiling " + "origin to equivalent one (" + xt0siz + "," + yt0siz
+ + ") so that " + "first tile overlaps the image");
+ }
+
+ // Calculate the number of tiles
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ ntX = (int)System.Math.Ceiling((x0siz + src.ImgWidth) / (double)xtsiz);
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ ntY = (int)System.Math.Ceiling((y0siz + src.ImgHeight) / (double)ytsiz);
+ }
+
+ /// Returns the width in pixels of the specified tile-component.
+ ///
+ ///
+ /// Tile index
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The width of specified tile-component.
+ ///
+ ///
+ public override int getTileCompWidth(int t, int c)
+ {
+ if (t != TileIdx)
+ {
+ throw new System.InvalidOperationException(
+ "Asking the width of a tile-component which is " + "not in the current tile (call setTile() or "
+ + "nextTile() methods before).");
+ }
+ return compW[c];
+ }
+
+ /// Returns the height in pixels of the specified tile-component.
+ ///
+ ///
+ /// The tile index.
+ ///
+ ///
+ /// The index of the component, from 0 to N-1.
+ ///
+ ///
+ /// The height of specified tile-component.
+ ///
+ ///
+ public override int getTileCompHeight(int t, int c)
+ {
+ if (t != TileIdx)
+ {
+ throw new System.InvalidOperationException(
+ "Asking the width of a tile-component which is " + "not in the current tile (call setTile() or "
+ + "nextTile() methods before).");
+ }
+ return compH[c];
+ }
+
+ /// Returns the position of the fixed point in the specified
+ /// component. This is the position of the least significant integral
+ /// (i.e. non-fractional) bit, which is equivalent to the number of
+ /// fractional bits. For instance, for fixed-point values with 2 fractional
+ /// bits, 2 is returned. For floating-point data this value does not apply
+ /// and 0 should be returned. Position 0 is the position of the least
+ /// significant bit in the data.
+ ///
+ ///
+ /// The index of the component.
+ ///
+ ///
+ /// The position of the fixed-point, which is the same as the
+ /// number of fractional bits. For floating-point data 0 is returned.
+ ///
+ ///
+ public virtual int getFixedPoint(int c)
+ {
+ return src.getFixedPoint(c);
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a reference to the internal data, if any, instead of as a
+ /// copy, therefore the returned data should not be modified.
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' and
+ /// 'scanw' of the returned data can be arbitrary. See the 'DataBlk'
+ /// class.
+ ///
+ /// This method, in general, is more efficient than the 'getCompData()'
+ /// method since it may not copy the data. However if the array of returned
+ /// data is to be modified by the caller then the other method is probably
+ /// preferable.
+ ///
+ /// If the data array in blk is null, then a new one
+ /// is created if necessary. The implementation of this interface may
+ /// choose to return the same array or a new one, depending on what is more
+ /// efficient. Therefore, the data array in blk prior to the
+ /// method call should not be considered to contain the returned data, a
+ /// new array may have been created. Instead, get the array from
+ /// blk after the method has returned.
+ ///
+ /// The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final"
+ /// data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. Some fields in this object are modified
+ /// to return the data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ public DataBlk getInternCompData(DataBlk blk, int c)
+ {
+ // Check that block is inside tile
+ if (blk.ulx < 0 || blk.uly < 0 || blk.w > compW[c] || blk.h > compH[c])
+ {
+ throw new System.ArgumentException("Block is outside the tile");
+ }
+ // Translate to the sources coordinates
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ int incx = (int)System.Math.Ceiling(x0siz / (double)src.getCompSubsX(c));
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ int incy = (int)System.Math.Ceiling(y0siz / (double)src.getCompSubsY(c));
+ blk.ulx -= incx;
+ blk.uly -= incy;
+ blk = src.getInternCompData(blk, c);
+ // Translate back to the tiled coordinates
+ blk.ulx += incx;
+ blk.uly += incy;
+ return blk;
+ }
+
+ /// Returns, in the blk argument, a block of image data containing the
+ /// specifed rectangular area, in the specified component. The data is
+ /// returned, as a copy of the internal data, therefore the returned data
+ /// can be modified "in place".
+ ///
+ /// The rectangular area to return is specified by the 'ulx', 'uly', 'w'
+ /// and 'h' members of the 'blk' argument, relative to the current
+ /// tile. These members are not modified by this method. The 'offset' of
+ /// the returned data is 0, and the 'scanw' is the same as the block's
+ /// width. See the 'DataBlk' class.
+ ///
+ /// This method, in general, is less efficient than the
+ /// 'getInternCompData()' method since, in general, it copies the
+ /// data. However if the array of returned data is to be modified by the
+ /// caller then this method is preferable.
+ ///
+ /// If the data array in 'blk' is 'null', then a new one is created. If
+ /// the data array is not 'null' then it is reused, and it must be large
+ /// enough to contain the block's data. Otherwise an 'ArrayStoreException'
+ /// or an 'IndexOutOfBoundsException' is thrown by the Java system.
+ ///
+ /// The returned data may have its 'progressive' attribute set. In this
+ /// case the returned data is only an approximation of the "final"
+ /// data.
+ ///
+ ///
+ /// Its coordinates and dimensions specify the area to return,
+ /// relative to the current tile. If it contains a non-null data array,
+ /// then it must be large enough. If it contains a null data array a new
+ /// one is created. Some fields in this object are modified to return the
+ /// data.
+ ///
+ ///
+ /// The index of the component from which to get the data.
+ ///
+ ///
+ /// The requested DataBlk
+ ///
+ ///
+ ///
+ ///
+ ///
+ public DataBlk getCompData(DataBlk blk, int c)
+ {
+ // Check that block is inside tile
+ if (blk.ulx < 0 || blk.uly < 0 || blk.w > compW[c] || blk.h > compH[c])
+ {
+ throw new System.ArgumentException("Block is outside the tile");
+ }
+ // Translate to the source's coordinates
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ int incx = (int)System.Math.Ceiling(x0siz / (double)src.getCompSubsX(c));
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ int incy = (int)System.Math.Ceiling(y0siz / (double)src.getCompSubsY(c));
+ blk.ulx -= incx;
+ blk.uly -= incy;
+ blk = src.getCompData(blk, c);
+ // Translate back to the tiled coordinates
+ blk.ulx += incx;
+ blk.uly += incy;
+ return blk;
+ }
+
+ /// Closes the underlying file or network connection from where the
+ /// image data is being read.
+ ///
+ ///
+ /// If an I/O error occurs.
+ ///
+ public void close()
+ {
+ // Do nothing.
+ }
+
+ /// Returns true if the data read was originally signed in the specified
+ /// component, false if not.
+ ///
+ ///
+ /// The index of the component, from 0 to C-1.
+ ///
+ ///
+ /// true if the data was originally signed, false if not.
+ ///
+ ///
+ public bool isOrigSigned(int c)
+ {
+ return false;
+ }
+
+ /// Changes the current tile, given the new tile indexes. An
+ /// IllegalArgumentException is thrown if the coordinates do not correspond
+ /// to a valid tile.
+ ///
+ ///
+ /// The horizontal index of the tile.
+ ///
+ ///
+ /// The vertical index of the new tile.
+ ///
+ ///
+ public override void setTile(int x, int y)
+ {
+ // Check tile indexes
+ if (x < 0 || y < 0 || x >= ntX || y >= ntY)
+ {
+ throw new System.ArgumentException("Tile's indexes out of bounds");
+ }
+
+ // Set new current tile
+ tx = x;
+ ty = y;
+ // Calculate tile origins
+ int tx0 = (x != 0) ? xt0siz + x * xtsiz : x0siz;
+ int ty0 = (y != 0) ? yt0siz + y * ytsiz : y0siz;
+ int tx1 = (x != ntX - 1) ? (xt0siz + (x + 1) * xtsiz) : (x0siz + src.ImgWidth);
+ int ty1 = (y != ntY - 1) ? (yt0siz + (y + 1) * ytsiz) : (y0siz + src.ImgHeight);
+ // Set general variables
+ tileW = tx1 - tx0;
+ tileH = ty1 - ty0;
+ // Set component specific variables
+ int nc = src.NumComps;
+ if (compW == null) compW = new int[nc];
+ if (compH == null) compH = new int[nc];
+ if (tcx0 == null) tcx0 = new int[nc];
+ if (tcy0 == null) tcy0 = new int[nc];
+ for (int i = 0; i < nc; i++)
+ {
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ tcx0[i] = (int)System.Math.Ceiling(tx0 / (double)src.getCompSubsX(i));
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ tcy0[i] = (int)System.Math.Ceiling(ty0 / (double)src.getCompSubsY(i));
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ compW[i] = (int)System.Math.Ceiling(tx1 / (double)src.getCompSubsX(i)) - tcx0[i];
+ //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
+ compH[i] = (int)System.Math.Ceiling(ty1 / (double)src.getCompSubsY(i)) - tcy0[i];
+ }
+ }
+
+ /// Advances to the next tile, in standard scan-line order (by rows then
+ /// columns). An NoNextElementException is thrown if the current tile is
+ /// the last one (i.e. there is no next tile).
+ ///
+ ///
+ public override void nextTile()
+ {
+ if (tx == ntX - 1 && ty == ntY - 1)
+ {
+ // Already at last tile
+ throw new NoNextElementException();
+ }
+ else if (tx < ntX - 1)
+ {
+ // If not at end of current tile line
+ setTile(tx + 1, ty);
+ }
+ else
+ {
+ // First tile at next line
+ setTile(0, ty + 1);
+ }
+ }
+
+ /// Returns the horizontal and vertical indexes of the current tile.
+ ///
+ ///
+ /// If not null this object is used to return the
+ /// information. If null a new one is created and returned.
+ ///
+ ///
+ /// The current tile's horizontal and vertical indexes..
+ ///
+ ///
+ public override Coord getTile(Coord co)
+ {
+ if (co != null)
+ {
+ co.x = tx;
+ co.y = ty;
+ return co;
+ }
+ else
+ {
+ return new Coord(tx, ty);
+ }
+ }
+
+ /// Returns the horizontal coordinate of the upper-left corner of the
+ /// specified component in the current tile.
+ ///
+ ///
+ /// The component index.
+ ///
+ ///
+ public override int getCompULX(int c)
+ {
+ return tcx0[c];
+ }
+
+ /// Returns the vertical coordinate of the upper-left corner of the
+ /// specified component in the current tile.
+ ///
+ ///
+ /// The component index.
+ ///
+ ///
+ public override int getCompULY(int c)
+ {
+ return tcy0[c];
+ }
+
+ /// Returns the number of tiles in the horizontal and vertical directions.
+ ///
+ ///
+ /// If not null this object is used to return the information. If
+ /// null a new one is created and returned.
+ ///
+ ///
+ /// The number of tiles in the horizontal (Coord.x) and vertical
+ /// (Coord.y) directions.
+ ///
+ ///
+ public override Coord getNumTiles(Coord co)
+ {
+ if (co != null)
+ {
+ co.x = ntX;
+ co.y = ntY;
+ return co;
+ }
+ else
+ {
+ return new Coord(ntX, ntY);
+ }
+ }
+
+ /// Returns the total number of tiles in the image.
+ ///
+ ///
+ /// The total number of tiles in the image.
+ ///
+ ///
+ public override int getNumTiles()
+ {
+ return ntX * ntY;
+ }
+
+ /// Returns the tiling origin, referred to as '(xt0siz,yt0siz)' in the
+ /// codestream header (SIZ marker segment).
+ ///
+ ///
+ /// If not null this object is used to return the information. If
+ /// null a new one is created and returned.
+ ///
+ ///
+ /// The coordinate of the tiling origin, in the canvas system, on
+ /// the reference grid.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public Coord getTilingOrigin(Coord co)
+ {
+ if (co != null)
+ {
+ co.x = xt0siz;
+ co.y = yt0siz;
+ return co;
+ }
+ else
+ {
+ return new Coord(xt0siz, yt0siz);
+ }
+ }
+
+ /// Returns a String object representing Tiler's informations
+ ///
+ ///
+ /// Tiler's infos in a string
+ ///
+ ///
+ public override System.String ToString()
+ {
+ //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
+ return "Tiler: source= " + src + "\n" + getNumTiles() + " tile(s), nominal width=" + xtsiz
+ + ", nominal height=" + ytsiz;
+ }
+ }
+}
diff --git a/CSJ2K/j2k/image/forwcomptransf/ForwCompTransf.cs b/CSJ2K/j2k/image/forwcomptransf/ForwCompTransf.cs
index 00af357f..c52a540d 100644
--- a/CSJ2K/j2k/image/forwcomptransf/ForwCompTransf.cs
+++ b/CSJ2K/j2k/image/forwcomptransf/ForwCompTransf.cs
@@ -441,8 +441,34 @@ namespace CSJ2K.j2k.image.forwcomptransf
return getInternCompData(blk, c);
}
}
-
- /// Apply the component transformation associated with the current tile. If
+
+ /// Closes the underlying file or network connection from where the
+ /// image data is being read.
+ ///
+ ///
+ /// If an I/O error occurs.
+ ///
+ public void close()
+ {
+ // Do nothing.
+ }
+
+ /// Returns true if the data read was originally signed in the specified
+ /// component, false if not.
+ ///
+ ///
+ /// The index of the component, from 0 to C-1.
+ ///
+ ///
+ /// true if the data was originally signed, false if not.
+ ///
+ ///
+ public bool isOrigSigned(int c)
+ {
+ return false;
+ }
+
+ /// Apply the component transformation associated with the current tile. If
/// no component transformation has been requested by the user, data are
/// not modified. Else, appropriate method is called (forwRCT or forwICT).
///
diff --git a/CSJ2K/j2k/image/input/ImgReader.cs b/CSJ2K/j2k/image/input/ImgReader.cs
index 7de37453..aecb5110 100644
--- a/CSJ2K/j2k/image/input/ImgReader.cs
+++ b/CSJ2K/j2k/image/input/ImgReader.cs
@@ -308,7 +308,7 @@ namespace CSJ2K.j2k.image.input
{
if (t != 0)
{
- throw new System.ApplicationException("Asking a tile-component width for a tile index" + " greater than 0 whereas there is only one tile");
+ throw new System.InvalidOperationException("Asking a tile-component width for a tile index" + " greater than 0 whereas there is only one tile");
}
return w;
}
@@ -333,7 +333,7 @@ namespace CSJ2K.j2k.image.input
{
if (t != 0)
{
- throw new System.ApplicationException("Asking a tile-component width for a tile index" + " greater than 0 whereas there is only one tile");
+ throw new System.InvalidOperationException("Asking a tile-component width for a tile index" + " greater than 0 whereas there is only one tile");
}
return h;
}
@@ -502,9 +502,9 @@ namespace CSJ2K.j2k.image.input
///
///
public abstract bool isOrigSigned(int c);
- public abstract int getFixedPoint(int param1);
- public abstract CSJ2K.j2k.image.DataBlk getInternCompData(CSJ2K.j2k.image.DataBlk param1, int param2);
- public abstract int getNomRangeBits(int param1);
- public abstract CSJ2K.j2k.image.DataBlk getCompData(CSJ2K.j2k.image.DataBlk param1, int param2);
+ public abstract int getFixedPoint(int c);
+ public abstract DataBlk getInternCompData(DataBlk blk, int c);
+ public abstract int getNomRangeBits(int c);
+ public abstract DataBlk getCompData(DataBlk blk, int c);
}
}
\ No newline at end of file
diff --git a/CSJ2K/j2k/image/input/ImgReaderPGM.cs b/CSJ2K/j2k/image/input/ImgReaderPGM.cs
index 3540030d..f72a7fce 100644
--- a/CSJ2K/j2k/image/input/ImgReaderPGM.cs
+++ b/CSJ2K/j2k/image/input/ImgReaderPGM.cs
@@ -39,6 +39,7 @@
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
using System;
+using CSJ2K.Util;
using CSJ2K.j2k.image;
using CSJ2K.j2k;
namespace CSJ2K.j2k.image.input
@@ -66,7 +67,7 @@ namespace CSJ2K.j2k.image.input
/// Where to read the data from
//UPGRADE_TODO: Class 'java.io.RandomAccessFile' was converted to 'System.IO.FileStream' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioRandomAccessFile'"
- private System.IO.FileStream in_Renamed;
+ private System.IO.Stream in_Renamed;
/// The offset of the raw pixel data in the PGM file
private int offset;
@@ -83,7 +84,7 @@ namespace CSJ2K.j2k.image.input
/// filters). This avoid allocating new DataBlk at each time
///
private DataBlkInt intBlk;
-
+
/// Creates a new PGM file reader from the specified file.
///
///
@@ -93,9 +94,10 @@ namespace CSJ2K.j2k.image.input
/// If an error occurs while opening the file.
///
///
- public ImgReaderPGM(System.IO.FileInfo file):this(SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(file, "r"))
+ public ImgReaderPGM(IFileInfo file)
+ : this(SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(file, "r"))
{
- }
+ }
/// Creates a new PGM file reader from the specified file name.
///
@@ -123,7 +125,7 @@ namespace CSJ2K.j2k.image.input
///
///