imgreaderpgm.java

jpeg2000算法实现

    public final DataBlk getInternCompData(DataBlk blk, int c) {
        int k,j,i,mi;
        int barr[];

        // Check component index
        if (c != 0)
            throw new IllegalArgumentException();

	// Check type of block provided as an argument
	if(blk.getDataType()!=DataBlk.TYPE_INT){
	    if(intBlk==null)
		intBlk = new DataBlkInt(blk.ulx,blk.uly,blk.w,blk.h);
	    else{
		intBlk.ulx = blk.ulx;
		intBlk.uly = blk.uly;
		intBlk.w = blk.w;
		intBlk.h = blk.h;
	    }
	    blk = intBlk;
	}
	
	// Get data array
	barr = (int[]) blk.getData();
	if (barr == null || barr.length < blk.w*blk.h) {
	    barr = new int[blk.w*blk.h];
	    blk.setData(barr); 
	}
       
        // Check line buffer
        if (buf == null || buf.length < blk.w) {
            buf = new byte[blk.w];
        }

        try {
            // Read line by line
            mi = blk.uly + blk.h;
            for (i = blk.uly; i < mi; i++) {
                // Reposition in input
                in.seek(offset+i*w+blk.ulx);
                in.read(buf,0,blk.w);
                for (k = (i-blk.uly)*blk.w+blk.w-1, j = blk.w-1;
                     j >= 0; j--, k--) {
                    barr[k] = (((int)buf[j])&0xFF)-DC_OFFSET;
                }
            }
        }
        catch (IOException e) {
            JJ2KExceptionHandler.handleException(e);
        }

        // Turn off the progressive attribute
        blk.progressive = false;
        // Set buffer attributes
        blk.offset = 0;
        blk.scanw = blk.w;
	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".
     *
     * <P> After being read the coefficients are level shifted by subtracting
     * 2^(nominal bit range - 1)
     *
     * <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>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>The returned data has its 'progressive' attribute unset
     * (i.e. false).
     *
     * <P>This method just calls 'getInternCompData(blk, n)'.
     *
     * <P>When an I/O exception is encountered the JJ2KExceptionHandler is
     * used. The exception is passed to its handleException method. The action
     * that is taken depends on the action that has been registered in
     * JJ2KExceptionHandler. See JJ2KExceptionHandler for details.
     *
     * @param blk Its coordinates and dimensions specify the area to
     * return. If it contains a non-null data array, then it must have the
     * correct dimensions. If it contains a null data array a new one is
     * created. The fields in this object are modified to return the data.
     *
     * @param c The index of the component from which to get the data. Only 0
     * is valid.
     *
     * @return The requested DataBlk
     *
     * @see #getInternCompData
     *
     * @see JJ2KExceptionHandler
     * */
    public DataBlk getCompData(DataBlk blk, int c) {
        return getInternCompData(blk,c);
    }

    /**
     * Returns a byte read from the RandomAccessIO. The number of read byted
     * are counted to keep track of the offset of the pixel data in the PGM
     * file
     *
     * @return One byte read from the header of the PGM file.
     *
     * @exception IOException If an I/O error occurs.
     *
     * @exception EOFException If an EOF is read 
     * */
     private byte countedByteRead() throws IOException, EOFException{
        offset++;
        return in.readByte();
    }
    
    /**
     * Checks that the RandomAccessIO begins with 'P5'
     *
     * @exception IOException If an I/O error occurs.
     * @exception EOFException If an EOF is read
     * */        
    private void confirmFileType() throws IOException, EOFException{
        byte[] type={80,53}; // 'P5'
        int i;
        byte b;

        for(i=0;i<2;i++){
            b = countedByteRead();
            if(b!=type[i]){
                if( i==1 && b==50 )  { //i.e 'P2'
                    throw new 
                        IllegalArgumentException("JJ2000 does not support"+
                                                 " ascii-PGM files. Use "+
                                                 " raw-PGM file instead. ");
                } else {
                    throw new IllegalArgumentException("Not a raw-PGM file");
                }
            }
        }
    }
    
    /**
     * Skips any line in the header starting with '#' and any space, tab, line
     * feed or carriage return.
     *
     * @exception IOException If an I/O error occurs.  
     * @exception EOFException if an EOF is read
     * */
    private void skipCommentAndWhiteSpace() throws IOException, EOFException {

        boolean done=false;
        byte b;
        
        while(!done){
            b=countedByteRead();
            if(b==35){ // Comment start
                while(b!=10 && b!=13){ // Comment ends in end of line
                    b=countedByteRead();
                }
            }else if(!(b==9||b==10||b==13||b==32)){ // If not whitespace
                done=true;
            }
        }
        // Put last valid byte in
        offset--;
        in.seek(offset);
    }
    
   
    /**
     * Returns an int read from the header of the PGM file.
     * 
     * @return One int read from the header of the PGM file.
     *
     * @exception IOException If an I/O error occurs.
     * @exception EOFException If an EOF is read 
     * */
    private int readHeaderInt() throws IOException, EOFException{
        int res=0;
        byte b=0;
        
        b=countedByteRead();   
        while(b!=32&&b!=10&&b!=9&&b!=13){ // While not whitespace
            res=res*10+b-48; // Covert ASCII to numerical value
            b=countedByteRead();    
        }
        return res;
    }
    
    /**
     * Returns true if the data read was originally signed in the specified
     * component, false if not. This method returns always false since PGM
     * data is always unsigned.
     *
     * @param c The index of the component, from 0 to N-1.
     *
     * @return always false, since PGM data is always unsigned.
     * */
    public boolean isOrigSigned(int c) {
        // Check component index
        if (c != 0)
            throw new IllegalArgumentException();
        return false;
    }

    /**
     * Returns a string of information about the object, more than 1 line
     * long. The information string includes information from the underlying
     * RandomAccessIO (its toString() method is called in turn).
     *
     * @return A string of information about the object.  
     * */
    public String toString() {
        return "ImgReaderPGM: WxH = " + w + "x" + h + ", Component = 0" +
            "\nUnderlying RandomAccessIO:\n" + in.toString();
    }
}