Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.lib.buffer.impl;

import java.io.IOException;

import java.nio.Buffer;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.BandTileManager;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractTiledBand extends AbstractBand implements Band {

    protected Buffer data; //data loaded

    protected int firstRowOfTile;

    protected int firstColumnOfTile;

    protected int rowsPerTile;

    protected int columnsPerTile;

    protected BandTileManager tileManager;

    private boolean loaded;

    protected int rowsInTile;

    protected int columnsInTile;

    /**

     * @param rows

     * @param columns

     * @param noData

     * @param tileManager

     */

    public AbstractTiledBand(int rows, int columns, NoData noData, BandTileManager tileManager) {

        this.rows = rows;

        this.columns = columns;

        this.loaded=false;

        this.rowsPerTile=tileManager.getRowsPerTile();

        this.columnsPerTile=tileManager.getColumnsPerTile();

        this.rowsInTile=rowsPerTile;

        this.columnsInTile=columnsPerTile;

        if (noData == null) {

            this.noData = BufferLocator.getBufferManager().createNoData(null, null);

        } else {

            this.noData = noData;

        }

        this.tileManager = tileManager;

    }

    @Override

    protected void doCopyFrom(Band source) throws CopyFromBandException {

        if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()

            || this.getDataType()!=source.getDataType() ) {

            throw new CopyFromBandException(source, this);

        }

        Object rowBuffer = this.createRowBuffer();

        for(int row = 0; row<=this.rows; row++){

            source.fetchRow(row, rowBuffer);

            this.putRow(row, rowBuffer);

        }

    }

    protected void loadTile(int row, int column) {

        //The tile to be loaded must be inside the band's limits

        if (loaded &&

            row >= firstRowOfTile &&

            row < firstRowOfTile + rowsPerTile &&

            column >= firstColumnOfTile &&

            column < firstColumnOfTile + columnsPerTile

            ) {

            return;

        }

        if(loaded) {

            saveCurrentTile();

        }

        loaded=false;

        int currentTileRow = row / rowsPerTile; //Divisi?n entera

        firstRowOfTile = currentTileRow * rowsPerTile;

        int currentTileColumn = column / columnsPerTile; //Divisi?n entera

        firstColumnOfTile = currentTileColumn * columnsPerTile;

        Band loadedBand = null;

        try {

            rowsInTile = rowsPerTile;

            if(firstRowOfTile + rowsPerTile > this.rows){

                rowsInTile = this.rows - firstRowOfTile;

            }

            columnsInTile = columnsPerTile;

            if(firstColumnOfTile + columnsPerTile > this.columns){

                columnsInTile = this.columns - firstColumnOfTile;

            }

            loadedBand = this.tileManager.load(firstRowOfTile,

                firstColumnOfTile,

                this.getDataType());

            Object rowBuffer = loadedBand.createRowBuffer();

            for(int loadedRow=0; loadedRow<loadedBand.getRows(); loadedRow++){

                loadedBand.fetchRow(loadedRow, rowBuffer);

                int pos = loadedRow*loadedBand.getColumns();

                System.arraycopy(rowBuffer, 0, data.array(), pos, loadedBand.getColumns());

            }

            loaded=true;

        } catch (IOException e) {

            throw new RuntimeException("Can't load current tile", e);

        } finally {

            DisposeUtils.dispose(loadedBand);

        }

    }

    protected void saveCurrentTile() {

        try {

            int rowsInTile = rowsPerTile;

            if(firstRowOfTile + rowsPerTile > this.rows){

                rowsInTile = this.rows - firstRowOfTile;

            }

            int columnsInTile = columnsPerTile;

            if(firstColumnOfTile + columnsPerTile > this.columns){

                columnsInTile = this.columns - firstColumnOfTile;

            }

            this.tileManager.save(data,

                firstRowOfTile, rowsInTile,

                firstColumnOfTile, columnsInTile,

                this.getDataType());

        } catch (UnsupportedOperationException e) {

            // Do nothing, operation not supported

        } catch (IOException e) {

            throw new RuntimeException("Can't save current tile", e);

        }

    }

    protected abstract int getDataSize();

    @Override

    public boolean isReadOnly() {

        if(this.tileManager==null){

            return false;

        }

        return !this.tileManager.isSupportedSave();

    }

    @Override

    public boolean isPaginated() {

        //FIXME: ?????

        return true;

    }

    @Override

    public BandInfo getBandInfo() {

        return this.tileManager == null ? null : this.tileManager.getBandInfo();

    }

    /**

     * Calculate buffer size than must be allocated.

     * @param rows

     * @param columns

     * @return

     */

    protected int calculateBufferSizeToAllocate(int rows, int columns){

        // If the number of requested cells is less than the default number of

        // cells, it is unnecessary to reserve the maximum possible size.

        int allocateRows = rowsInTile;

        if(rows<rowsInTile){

            allocateRows = rows;

        }

        int allocateColumns = columnsInTile;

        //FIXME: Comprobar si se puede utilizar la condici?n de abajo antes de descomentarizarla

//        if(columns<columnsInTile){

//            allocateColumns = columns;

//        }

        return allocateRows*allocateColumns;

    }

    @Override

    public void doDispose() throws BaseException {

        super.doDispose();

        data = null;

        //FIXME: ?hacer disposables los pageManagers?

        tileManager = null;

    }

}