/*
* CVS identifier:
*
* $Id: Tiler.java,v 1.34 2001/09/14 09:16:09 grosbois Exp $
*
* Class:                   Tiler
*
* Description:             An object to create TiledImgData from
*                          ImgData
*
*
*
* COPYRIGHT:
* 
* This software module was originally developed by Raphaël Grosbois and
* Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
* Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
* Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
* Centre France S.A) in the course of development of the JPEG2000
* standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
* software module is an implementation of a part of the JPEG 2000
* Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
* Systems AB and Canon Research Centre France S.A (collectively JJ2000
* Partners) agree not to assert against ISO/IEC and users of the JPEG
* 2000 Standard (Users) any of their rights under the copyright, not
* including other intellectual property rights, for this software module
* with respect to the usage by ISO/IEC and Users of this software module
* or modifications thereof for use in hardware or software products
* claiming conformance to the JPEG 2000 Standard. Those intending to use
* this software module in hardware or software products are advised that
* their use may infringe existing patents. The original developers of
* this software module, JJ2000 Partners and ISO/IEC assume no liability
* for use of this software module or modifications thereof. No license
* or right to this software module is granted for non JPEG 2000 Standard
* conforming products. JJ2000 Partners have full right to use this
* software module for his/her own purpose, assign or donate this
* software module to any third party and to inhibit third parties from
* using this software module for non JPEG 2000 Standard conforming
* products. This copyright notice must be included in all copies or
* derivative works of this software module.
* 
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
using System;
using CSJ2K.j2k.util;
using CSJ2K.j2k;
namespace CSJ2K.j2k.image
{
	
	/// <summary> 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.
	/// 
	/// <p>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.</p>
	/// 
	/// <p>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.</p>
	/// 
	/// </summary>
	/// <seealso cref="ImgData">
	/// </seealso>
	/// <seealso cref="BlkImgDataSrc">
	/// 
	/// </seealso>
	public class Tiler:ImgDataAdapter, BlkImgDataSrc
	{
		/// <summary> Returns the overall width of the current tile in pixels. This is the
		/// tile's width without accounting for any component subsampling.
		/// 
		/// </summary>
		/// <returns> The total current tile width in pixels.
		/// 
		/// </returns>
		override public int TileWidth
		{
			get
			{
				return tileW;
			}
			
		}
		/// <summary> Returns the overall height of the current tile in pixels. This is the
		/// tile's width without accounting for any component subsampling.
		/// 
		/// </summary>
		/// <returns> The total current tile height in pixels.
		/// 
		/// </returns>
		override public int TileHeight
		{
			get
			{
				return tileH;
			}
			
		}
		/// <summary> Returns the index of the current tile, relative to a standard scan-line
		/// order.
		/// 
		/// </summary>
		/// <returns> The current tile's index (starts at 0).
		/// 
		/// </returns>
		override public int TileIdx
		{
			get
			{
				return ty * ntX + tx;
			}
			
		}
		/// <summary>Returns the horizontal tile partition offset in the reference grid </summary>
		override public int TilePartULX
		{
			get
			{
				return xt0siz;
			}
			
		}
		/// <summary>Returns the vertical tile partition offset in the reference grid </summary>
		override public int TilePartULY
		{
			get
			{
				return yt0siz;
			}
			
		}
		/// <summary> Returns the horizontal coordinate of the image origin, the top-left
		/// corner, in the canvas system, on the reference grid.
		/// 
		/// </summary>
		/// <returns> The horizontal coordinate of the image origin in the canvas
		/// system, on the reference grid.
		/// 
		/// </returns>
		override public int ImgULX
		{
			get
			{
				return x0siz;
			}
			
		}
		/// <summary> Returns the vertical coordinate of the image origin, the top-left
		/// corner, in the canvas system, on the reference grid.
		/// 
		/// </summary>
		/// <returns> The vertical coordinate of the image origin in the canvas
		/// system, on the reference grid.
		/// 
		/// </returns>
		override public int ImgULY
		{
			get
			{
				return y0siz;
			}
			
		}
		/// <summary> Returns the nominal width of the tiles in the reference grid.
		/// 
		/// </summary>
		/// <returns> The nominal tile width, in the reference grid.
		/// 
		/// </returns>
		override public int NomTileWidth
		{
			get
			{
				return xtsiz;
			}
			
		}
		/// <summary> Returns the nominal width of the tiles in the reference grid.
		/// 
		/// </summary>
		/// <returns> The nominal tile width, in the reference grid.
		/// 
		/// </returns>
		override public int NomTileHeight
		{
			get
			{
				return ytsiz;
			}
			
		}
		
		/// <summary>The source of image data </summary>
		private BlkImgDataSrc src = null;
		
		/// <summary>Horizontal coordinate of the upper left hand reference grid point.</summary>
		private int x0siz;
		
		/// <summary>Vertical coordinate of the upper left hand reference grid point.</summary>
		private int y0siz;
		
		/// <summary>The horizontal coordinate of the tiling origin in the canvas system,
		/// on the reference grid. 
		/// </summary>
		private int xt0siz;
		
		/// <summary>The vertical coordinate of the tiling origin in the canvas system, on
		/// the reference grid. 
		/// </summary>
		private int yt0siz;
		
		/// <summary>The nominal width of the tiles, on the reference grid. If 0 then there 
		/// is no tiling in that direction. 
		/// </summary>
		private int xtsiz;
		
		/// <summary>The nominal height of the tiles, on the reference grid. If 0 then
		/// there is no tiling in that direction. 
		/// </summary>
		private int ytsiz;
		
		/// <summary>The number of tiles in the horizontal direction. </summary>
		private int ntX;
		
		/// <summary>The number of tiles in the vertical direction. </summary>
		private int ntY;
		
		/// <summary>The component width in the current active tile, for each component </summary>
		private int[] compW = null;
		
		/// <summary>The component height in the current active tile, for each component </summary>
		private int[] compH = null;
		
		/// <summary>The horizontal coordinates of the upper-left corner of the components
		/// in the current tile 
		/// </summary>
		private int[] tcx0 = null;
		
		/// <summary>The vertical coordinates of the upper-left corner of the components in
		/// the current tile. 
		/// </summary>
		private int[] tcy0 = null;
		
		/// <summary>The horizontal index of the current tile </summary>
		private int tx;
		
		/// <summary>The vertical index of the current tile </summary>
		private int ty;
		
		/// <summary>The width of the current tile, on the reference grid. </summary>
		private int tileW;
		
		/// <summary>The height of the current tile, on the reference grid. </summary>
		private int tileH;
		
		/// <summary> Constructs a new tiler with the specified 'BlkImgDataSrc' source,
		/// image origin, tiling origin and nominal tile size.
		/// 
		/// </summary>
		/// <param name="src">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.
		/// 
		/// </param>
		/// <param name="ax">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).
		/// 
		/// </param>
		/// <param name="ay">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).
		/// 
		/// </param>
		/// <param name="px">The horizontal tiling origin, in the canvas system, on the
		/// reference grid. It must satisfy 'px<=ax'.
		/// 
		/// </param>
		/// <param name="py">The vertical tiling origin, in the canvas system, on the
		/// reference grid. It must satisfy 'py<=ay'.
		/// 
		/// </param>
		/// <param name="nw">The nominal tile width, on the reference grid. If 0 then
		/// there is no tiling in that direction.
		/// 
		/// </param>
		/// <param name="nh">The nominal tile height, on the reference grid. If 0 then
		/// there is no tiling in that direction.
		/// 
		/// </param>
		/// <exception cref="IllegalArgumentException">If src is tiled or "canvased", or
		/// if the arguments do not satisfy the specified constraints.
		/// 
		/// </exception>
		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);
		}
		
		/// <summary> Returns the width in pixels of the specified tile-component.
		/// 
		/// </summary>
		/// <param name="t">Tile index
		/// 
		/// </param>
		/// <param name="c">The index of the component, from 0 to N-1.
		/// 
		/// </param>
		/// <returns> The width of specified tile-component.
		/// 
		/// </returns>
		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];
		}
		
		/// <summary> Returns the height in pixels of the specified tile-component.
		/// 
		/// </summary>
		/// <param name="t">The tile index.
		/// 
		/// </param>
		/// <param name="c">The index of the component, from 0 to N-1.
		/// 
		/// </param>
		/// <returns> The height of specified tile-component.
		/// 
		/// </returns>
		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];
		}
		
		/// <summary> 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.
		/// 
		/// </summary>
		/// <param name="c">The index of the component.
		/// 
		/// </param>
		/// <returns> The position of the fixed-point, which is the same as the
		/// number of fractional bits. For floating-point data 0 is returned.
		/// 
		/// </returns>
		public virtual int getFixedPoint(int c)
		{
			return src.getFixedPoint(c);
		}
		
		/// <summary> 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.
		/// 
		/// <p>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.</p>
		/// 
		/// <p>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.</p>
		/// 
		/// <p>If the data array in <tt>blk</tt> is <tt>null</tt>, 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 <tt>blk</tt> 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
		/// <tt>blk</tt> after the method has returned.</p>
		/// 
		/// <p>The returned data may have its 'progressive' attribute set. In this
		/// case the returned data is only an approximation of the "final"
		/// data.</p>
		/// 
		/// </summary>
		/// <param name="blk">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.
		/// 
		/// </param>
		/// <param name="c">The index of the component from which to get the data.
		/// 
		/// </param>
		/// <returns> The requested DataBlk
		/// 
		/// </returns>
		/// <seealso cref="getCompData">
		/// 
		/// </seealso>
		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;
		}
		
		/// <summary> 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".
		/// 
		/// <p>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.</p>
		/// 
		/// <p>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.</p>
		/// 
		/// <p>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.</p>
		/// 
		/// <p>The returned data may have its 'progressive' attribute set. In this
		/// case the returned data is only an approximation of the "final"
		/// data.</p>
		/// 
		/// </summary>
		/// <param name="blk">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.
		/// 
		/// </param>
		/// <param name="c">The index of the component from which to get the data.
		/// 
		/// </param>
		/// <returns> The requested DataBlk
		/// 
		/// </returns>
		/// <seealso cref="getInternCompData">
		/// 
		/// </seealso>
		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;
		}
		
		/// <summary> Changes the current tile, given the new tile indexes. An
		/// IllegalArgumentException is thrown if the coordinates do not correspond
		/// to a valid tile.
		/// 
		/// </summary>
		/// <param name="x">The horizontal index of the tile.
		/// 
		/// </param>
		/// <param name="y">The vertical index of the new tile.
		/// 
		/// </param>
		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];
			}
		}
		
		/// <summary> 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).
		/// 
		/// </summary>
		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);
			}
		}
		
		/// <summary> Returns the horizontal and vertical indexes of the current tile.
		/// 
		/// </summary>
		/// <param name="co">If not null this object is used to return the
		/// information. If null a new one is created and returned.
		/// 
		/// </param>
		/// <returns> The current tile's horizontal and vertical indexes..
		/// 
		/// </returns>
		public override Coord getTile(Coord co)
		{
			if (co != null)
			{
				co.x = tx;
				co.y = ty;
				return co;
			}
			else
			{
				return new Coord(tx, ty);
			}
		}
		
		/// <summary> Returns the horizontal coordinate of the upper-left corner of the
		/// specified component in the current tile.
		/// 
		/// </summary>
		/// <param name="c">The component index.
		/// 
		/// </param>
		public override int getCompULX(int c)
		{
			return tcx0[c];
		}
		
		/// <summary> Returns the vertical coordinate of the upper-left corner of the
		/// specified component in the current tile.
		/// 
		/// </summary>
		/// <param name="c">The component index.
		/// 
		/// </param>
		public override int getCompULY(int c)
		{
			return tcy0[c];
		}
		
		/// <summary> Returns the number of tiles in the horizontal and vertical directions.
		/// 
		/// </summary>
		/// <param name="co">If not null this object is used to return the information. If
		/// null a new one is created and returned.
		/// 
		/// </param>
		/// <returns> The number of tiles in the horizontal (Coord.x) and vertical
		/// (Coord.y) directions.
		/// 
		/// </returns>
		public override Coord getNumTiles(Coord co)
		{
			if (co != null)
			{
				co.x = ntX;
				co.y = ntY;
				return co;
			}
			else
			{
				return new Coord(ntX, ntY);
			}
		}
		
		/// <summary> Returns the total number of tiles in the image.
		/// 
		/// </summary>
		/// <returns> The total number of tiles in the image.
		/// 
		/// </returns>
		public override int getNumTiles()
		{
			return ntX * ntY;
		}
		
		/// <summary> Returns the tiling origin, referred to as '(xt0siz,yt0siz)' in the
		/// codestream header (SIZ marker segment).
		/// 
		/// </summary>
		/// <param name="co">If not null this object is used to return the information. If
		/// null a new one is created and returned.
		/// 
		/// </param>
		/// <returns> The coordinate of the tiling origin, in the canvas system, on
		/// the reference grid.
		/// 
		/// </returns>
		/// <seealso cref="ImgData">
		/// 
		/// </seealso>
		public Coord getTilingOrigin(Coord co)
		{
			if (co != null)
			{
				co.x = xt0siz;
				co.y = yt0siz;
				return co;
			}
			else
			{
				return new Coord(xt0siz, yt0siz);
			}
		}
		
		/// <summary> Returns a String object representing Tiler's informations
		/// 
		/// </summary>
		/// <returns> Tiler's infos in a string
		/// 
		/// </returns>
		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;
		}
	}
}