/* * CVS identifier: * * $Id: ImgDataJoiner.java,v 1.1.1.1 2002/07/22 09:26:50 grosbois Exp $ * * Class:                   ImgDataJoiner * * Description:             Get ImgData from different sources * * * * 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.*;/** * 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). * * <p>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).</p> * * <p>The input ImgData and component index list must be defined when * constructing this class and can not be modified later.</p> * * @see ImgData * @see jj2000.j2k.image.input.ImgReader * */public class ImgDataJoiner implements BlkImgDataSrc {    /** 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.<br>     *     * <u>Example:</u> Reading R,G,B components from 3 PGM files.<br>     * <tt>     * BlkImgDataSrc[] idList = <br>     *   {<br>     *   new ImgReaderPGM(new BEBufferedRandomAccessFile("R.pgm", "r")),<br>     *   new ImgReaderPGM(new BEBufferedRandomAccessFile("G.pgm", "r")),<br>     *   new ImgReaderPGM(new BEBufferedRandomAccessFile("B.pgm", "r"))<br>     *   };<br>     * int[] compIdx = {0,0,0};<br>     * ImgDataJoiner idj = new ImgDataJoiner(idList, compIdx);     * </tt>     *     * <p>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.     *     * @param imD The list of input BlkImgDataSrc in an array.     *     * @param cIdx 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 IllegalArgumentException("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 IllegalArgumentException("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 Error("Can not compute component subsampling "+                                "factors: strange subsampling.");            }        }    }    /**     * 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's width in pixels.     * */    public int getTileWidth(){	return w;    }    /**     * Returns the overall height of the current tile in pixels. This is the     * tile's height without accounting for any component subsampling.     *     * @return The total current tile's height in pixels.     * */    public int getTileHeight(){	return h;    }    /** Returns the nominal tiles width */    public int getNomTileWidth() {        return w;    }    /** Returns the nominal tiles height */    public int getNomTileHeight() {        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.     *     * @return The total image's width in pixels.     * */    public int getImgWidth(){	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.     *     * @return The total image's height in pixels.     * */    public int getImgHeight(){	return h;    }    /**     * Returns the number of components in the image.     *     * @return The number of components in the image.     * */    public int getNumComps(){	return nc;    }    /**     * 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.     *     * @param c The index of the component (between 0 and N-1)     *     * @return The horizontal subsampling factor of component 'c'     *     * @see ImgData     * */    public 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.     *     * @param c The index of the component (between 0 and N-1)     *     * @return The vertical subsampling factor of component 'c'     *     * @see ImgData     * */    public int getCompSubsY(int c) {        return subsY[c];    }    /**     * 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 in pixels of component <tt>c</tt> in tile<tt>t</tt>.     * */    public int getTileCompWidth(int t,int c){	return imageData[c].getTileCompWidth(t,compIdx[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 in pixels of component <tt>c</tt> in the current     * tile.     * */    public int getTileCompHeight(int t,int c){	return imageData[c].getTileCompHeight(t,compIdx[c]);    }