/* * CVS identifier: * * $Id: Tiler.java,v 1.1.1.1 2002/07/22 09:26:50 grosbois Exp $ * * Class:                   Tiler * * Description:             An object to create TiledImgData from *                          ImgData * * * * COPYRIGHT: *  * This software module was originally developed by Rapha雔 Grosbois and * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel * Askel鰂 (Ericsson Radio Systems AB); and Bertrand Berthelot, David * Bouchard, F閘ix 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. * */package jj2000.j2k.image;import jj2000.j2k.util.*;import jj2000.j2k.*;/** * 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> * * @see ImgData * @see BlkImgDataSrc * */public class Tiler extends ImgDataAdapter implements BlkImgDataSrc {    /** 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.     *     * @param 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 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 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 px The horizontal tiling origin, in the canvas system, on the     * reference grid. It must satisfy 'px<=ax'.     *     * @param py The vertical tiling origin, in the canvas system, on the     * reference grid. It must satisfy 'py<=ay'.     *     * @param nw The nominal tile width, on the reference grid. If 0 then     * there is no tiling in that direction.     *     * @param nh The nominal tile height, on the reference grid. If 0 then     * there is no tiling in that direction.     *     * @exception IllegalArgumentException 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) {        super(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 IllegalArgumentException("Source is tiled");        }        // Verify that source is not "canvased"        if (src.getImgULX()!=0 || src.getImgULY()!=0) {            throw new IllegalArgumentException("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 IllegalArgumentException("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.getImgWidth()-xt0siz;        if (ytsiz==0) ytsiz = y0siz+src.getImgHeight()-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(MsgLogger.INFO,"Automatically adjusted tiling "+                         "origin to equivalent one ("+xt0siz+","+                         yt0siz+") so that "+                         "first tile overlaps the image");        }        // Calculate the number of tiles        ntX = (int)Math.ceil((x0siz+src.getImgWidth())/(double)xtsiz);        ntY = (int)Math.ceil((y0siz+src.getImgHeight())/(double)ytsiz);    }    /**     * Returns the overall width of the current tile in pixels. This is the     * tile's width without accounting for any component subsampling.     *     * @return The total current tile width in pixels.     * */    public final int getTileWidth() {        return tileW;    }    /**     * Returns the overall height of the current tile in pixels. This is the     * tile's width without accounting for any component subsampling.     *     * @return The total current tile height in pixels.     * */    public final int getTileHeight() {        return tileH;    }    /**     * Returns the width in pixels of the specified tile-component.     *     * @param t Tile index     *     * @param c The index of the component, from 0 to N-1.     *     * @return The width of specified tile-component.     * */    public final int getTileCompWidth(int t,int c) {        if(t!=getTileIdx()) {            throw new Error("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.     *     * @param t The tile index.     *     * @param c The index of the component, from 0 to N-1.     *     * @return The height of specified tile-component.     * */    public final int getTileCompHeight(int t,int c) {        if(t!=getTileIdx()) {            throw new Error("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.     *     * @param c The index of the component.     *     * @return The position of the fixed-point, which is the same as the     * number of fractional bits. For floating-point data 0 is returned.     * */    public 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.     *     * <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