forwcomptransf.java

jpeg2000算法实现

    /**
     * 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).
     *
     * @see #forwRCT
     *
     * @see #forwICT
     *
     * @param blk Determines the rectangular area to return.
     *
     * @param c Index of the output component.
     *
     * @return The requested DataBlk
     * */
    public DataBlk getInternCompData(DataBlk blk, int c){
        switch(transfType){
        case NONE:
 	    return src.getInternCompData(blk,c);
        case FORW_RCT:
	    return forwRCT(blk,c);
        case FORW_ICT:
	    return forwICT(blk,c);
        default:
            throw new IllegalArgumentException("Non JPEG 2000 part I component"+
                                               " transformation for tile: "+
                                               tIdx);
        }
    }

    /** 
     * Apply forward component transformation to obtain requested component
     * from specified block of data. Whatever the type of requested DataBlk,
     * it always returns a DataBlkInt.
     *
     * @param blk Determine the rectangular area to return 
     *
     * @param c The index of the requested component
     *
     * @return Data of requested component
     * */
    private DataBlk forwRCT(DataBlk blk,int c){
        int k,k0,k1,k2,mink,i;
        int w = blk.w; //width of output block
        int h = blk.h; //height of ouput block
        int  outdata[]; //array of output data

        //If asking for Yr, Ur or Vr do transform
        if(c >= 0 && c <= 2) {
	    // Check that request data type is int
	    if(blk.getDataType()!=DataBlk.TYPE_INT){
		if(outBlk==null || outBlk.getDataType() != DataBlk.TYPE_INT){
		    outBlk = new DataBlkInt();
		}
		outBlk.w = w;
		outBlk.h = h;
		outBlk.ulx = blk.ulx;
		outBlk.uly = blk.uly;
		blk = outBlk;
	    }

            //Reference to output block data array
            outdata = (int[]) blk.getData();

            //Create data array of blk if necessary
            if(outdata == null || outdata.length<h*w) {
                outdata = new int[h*w];
                blk.setData(outdata);
            }

            // Block buffers for input RGB data
            int data0[],data1[],bdata[]; // input data arrays

	    if(block0==null)
		block0 = new DataBlkInt();
	    if(block1==null)
		block1 = new DataBlkInt();
	    if(block2==null)
		block2 = new DataBlkInt(); 
	    block0.w = block1.w = block2.w = blk.w;
	    block0.h = block1.h = block2.h = blk.h;
	    block0.ulx = block1.ulx = block2.ulx = blk.ulx;
	    block0.uly = block1.uly = block2.uly = blk.uly;

            //Fill in buffer blocks (to be read only)
            // Returned blocks may have different size and position
            block0 = (DataBlkInt)src.getInternCompData(block0, 0);
            data0 = (int[]) block0.getData();
            block1 = (DataBlkInt)src.getInternCompData(block1, 1);
            data1 = (int[]) block1.getData();
            block2 = (DataBlkInt)src.getInternCompData(block2, 2);
            bdata = (int[]) block2.getData();

            // Set the progressiveness of the output data
            blk.progressive = block0.progressive || block1.progressive ||
                block2.progressive;
	    blk.offset = 0;
            blk.scanw = w;

            //Perform conversion

            // Initialize general indexes
            k = w*h-1;
            k0 = block0.offset+(h-1)*block0.scanw+w-1;
            k1 = block1.offset+(h-1)*block1.scanw+w-1;
            k2 = block2.offset+(h-1)*block2.scanw+w-1;

            switch(c) {
            case 0: //RGB to Yr conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k0--, k1--, k2--) {
                        // Use int arithmetic with 12 fractional bits
                        // and rounding
                        outdata[k] =
                            ( data0[k] + 2 * data1[k] + bdata[k]
                              ) >> 2; // Same as / 4
                    }
                    // Jump to beggining of previous line in input
                    k0 -= block0.scanw - w;
                    k1 -= block1.scanw - w;
                    k2 -= block2.scanw - w;
                }
                break;
		
	    case 1: //RGB to Ur conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k1--, k2--) {
                        // Use int arithmetic with 12 fractional bits
                        // and rounding
                        outdata[k] = bdata[k2] - data1[k1];
                    }
                    // Jump to beggining of previous line in input
                    k1 -= block1.scanw - w;
                    k2 -= block2.scanw - w;
                }
                break;

	    case 2:  //RGB to Vr conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k0--, k1--) {
                        // Use int arithmetic with 12 fractional bits
                        // and rounding
                        outdata[k] = data0[k0] - data1[k1];
                    }
                    // Jump to beggining of previous line in input
                    k0 -= block0.scanw - w;
                    k1 -= block1.scanw - w;
                }
                break;
		
            }
        }
        else if (c >= 3) {
            // Requesting a component which is not Y, Ur or Vr =>
            // just pass the data            
            return src.getInternCompData(blk,c);
        }
        else {
            // Requesting a non valid component index
            throw new IllegalArgumentException();
        }
	return blk;

    }

    /** 
     * Apply forward irreversible component transformation to obtain requested
     * component from specified block of data. Whatever the type of requested
     * DataBlk, it always returns a DataBlkFloat.
     *
     * @param blk Determine the rectangular area to return 
     *
     * @param c The index of the requested component
     *
     * @return Data of requested component
     * */
    private DataBlk forwICT(DataBlk blk,int c){
        int k,k0,k1,k2,mink,i;
        int w = blk.w; //width of output block
        int h = blk.h; //height of ouput block
        float  outdata[]; //array of output data
	
	if(blk.getDataType()!=DataBlk.TYPE_FLOAT){
	    if(outBlk==null || outBlk.getDataType() != DataBlk.TYPE_FLOAT){
		outBlk = new DataBlkFloat();
	    }
	    outBlk.w = w;
	    outBlk.h = h;
	    outBlk.ulx = blk.ulx;
	    outBlk.uly = blk.uly;
	    blk = outBlk;
	}
	
	//Reference to output block data array
	outdata = (float[]) blk.getData();
	
	//Create data array of blk if necessary
	if(outdata == null) {
	    outdata = new float[h * w];
	    blk.setData(outdata);
	}

        //If asking for Y, Cb or Cr do transform
        if(c>=0 && c<=2) {
        
            int data0[],data1[],data2[]; // input data arrays

	    if(block0==null)
		block0 = new DataBlkInt();
	    if(block1==null)
		block1 = new DataBlkInt();
	    if(block2==null)
		block2 = new DataBlkInt(); 
	    block0.w = block1.w = block2.w = blk.w;
	    block0.h = block1.h = block2.h = blk.h;
	    block0.ulx = block1.ulx = block2.ulx = blk.ulx;
	    block0.uly = block1.uly = block2.uly = blk.uly;

            // Returned blocks may have different size and position
            block0 = (DataBlkInt)src.getInternCompData(block0, 0);
            data0 = (int[]) block0.getData();
            block1 = (DataBlkInt)src.getInternCompData(block1, 1);
            data1 = (int[]) block1.getData();
            block2 = (DataBlkInt)src.getInternCompData(block2, 2);
            data2 = (int[]) block2.getData();

            // Set the progressiveness of the output data
            blk.progressive = block0.progressive || block1.progressive ||
                block2.progressive;
	    blk.offset = 0;
            blk.scanw = w;

            //Perform conversion

            // Initialize general indexes
            k = w*h-1;
            k0 = block0.offset+(h-1)*block0.scanw+w-1;
            k1 = block1.offset+(h-1)*block1.scanw+w-1;
            k2 = block2.offset+(h-1)*block2.scanw+w-1;

            switch(c) {
            case 0: 
            //RGB to Y conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k0--, k1--, k2--) {
                        outdata[k] =
                            0.299f * data0[k0]
                            + 0.587f * data1[k1]
                            + 0.114f * data2[k2];
		    }
                    // Jump to beggining of previous line in input
                    k0 -= block0.scanw - w;
                    k1 -= block1.scanw - w;
                    k2 -= block2.scanw - w;
		}
                break;
               
            case 1:  
            //RGB to Cb conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k0--, k1--, k2--) {
			outdata[k] =
			    - 0.16875f * data0[k0]
			    - 0.33126f * data1[k1]
			    + 0.5f * data2[k2];
		    }
                    // Jump to beggining of previous line in input
                    k0 -= block0.scanw - w;
                    k1 -= block1.scanw - w;
                    k2 -= block2.scanw - w;
		}
                break;
               
            case 2:
            //RGB to Cr conversion
                for (i = h-1; i >= 0; i--) {
                    for (mink = k-w; k > mink; k--, k0--, k1--, k2--) {
			outdata[k] =
			    0.5f * data0[k0]
			    - 0.41869f * data1[k1]
			    - 0.08131f * data2[k2];
		    }
                    // Jump to beggining of previous line in input
                    k0 -= block0.scanw - w;
                    k1 -= block1.scanw - w;
                    k2 -= block2.scanw - w;
		}
                break;
            }
        }
        else if(c>=3) {
            // Requesting a component which is not Y, Cb or Cr =>
            // just pass the data
            
            // Variables
            DataBlkInt indb = new DataBlkInt(blk.ulx,blk.uly,w,h);
            int indata[]; // input data array

            // Get the input data
            // (returned block may be larger than requested one)
            src.getInternCompData(indb,c);
            indata = (int[]) indb.getData();

            // Copy the data converting from int to float
            k = w*h-1;
            k0 = indb.offset+(h-1)*indb.scanw+w-1;
            for (i=h-1; i>=0; i--) {
                for (mink = k-w; k > mink; k--, k0--) {
                    outdata[k] = (float) indata[k0];
                }
                // Jump to beggining of next line in input
                k0 += indb.w - w;
            }

            // Set the progressivity
            blk.progressive = indb.progressive;
            blk.offset = 0;
            blk.scanw = w;
	    return blk;
        }
        else {
            // Requesting a non valid component index
            throw new IllegalArgumentException();
        }
	return blk;
	
    }

    /**
     * Changes the current tile, given the new indexes. An
     * IllegalArgumentException is thrown if the indexes do not correspond to
     * a valid tile.
     *
     * <P>This default implementation changes the tile in the source and
     * re-initializes properly component transformation variables..
     *
     * @param x The horizontal index of the tile.
     *
     * @param y The vertical index of the new tile.
     * */
    public void setTile(int x, int y) {
        src.setTile(x,y);
	tIdx = getTileIdx(); // index of the current tile

        // initializations
        String str = (String)cts.getTileDef(tIdx);
        if(str.equals("none")){
            transfType = NONE;
        }
        else if(str.equals("rct")){
            transfType = FORW_RCT;
            initForwRCT();
        }
        else if(str.equals("ict")){
            transfType = FORW_ICT;
            initForwICT();
        }            
        else{
            throw new IllegalArgumentException("Component transformation"+
                                               " not recognized");
        }
    }

    /**
     * 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).
     *
     * <P>This default implementation just advances to the next tile in the
     * source and re-initializes properly component transformation variables.
     * */
    public void nextTile() {
        src.nextTile();
	tIdx = getTileIdx(); // index of the current tile

        // initializations
        String str = (String)cts.getTileDef(tIdx);
        if(str.equals("none")){
            transfType = NONE;
        }
        else if(str.equals("rct")){
            transfType = FORW_RCT;
            initForwRCT();
        }
        else if(str.equals("ict")){
            transfType = FORW_ICT;
            initForwICT();
        }            
        else{
            throw new IllegalArgumentException("Component transformation"+
                                               " not recognized");
        }
    }

}