Application: gvSIG desktop » gvSIG raster

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

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.raster.lib.buffer.api.exceptions.BandException;

import org.gvsig.raster.lib.buffer.api.statistics.Statistics;

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

import org.gvsig.raster.lib.buffer.impl.statistics.DefaultStatistics;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author fdiaz

 *

 */

public class DefaultBuffer implements Buffer {

    protected static final Logger logger = LoggerFactory.getLogger(DefaultBuffer.class);

    private List<Band> bands;

    private int rows;

    private int columns;

    private FilterList filters;

    private Envelope envelope;

    private IProjection projection;

    private PageManager bandPageManager;

    private Statistics statistics;

    /**

     * Default constructor of buffer.

     *

     * @param rows

     *            Rows of buffer and buffer bands.

     * @param columns

     *            Columns of buffer bands.

     * @param bandDataTypes

     *            Type of buffer bands. The band types also indicates the number

     *            of buffer bands.

     * @param bandNoData

     *            Band noData. If there are bans without NoData, bands will have

     *            undefined NoData value.

     * @param projection

     *            Projection of buffer

     * @param envelope

     *            Envelope of buffer

     * @param pageManager

     *            Page manager to paginate this buffer. If page manager is null,

     *            buffer will be loaded in memory.

     * @throws CreateBufferException

     *             If there are some problems creating buffer.

     */

    public DefaultBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData,

        IProjection projection, Envelope envelope, PageManager pageManager)

        throws CreateBufferException {

        this.bands = new ArrayList<Band>();

        this.rows = rows;

        this.columns = columns;

        this.projection = projection;

        this.envelope = envelope;

        try {

            if (envelope == null) {

                this.envelope =

                    GeometryLocator.getGeometryManager().createEnvelope(0, 0, columns, rows, Geometry.SUBTYPES.GEOM2D);

            }

            this.bandPageManager = pageManager;

            createBands(bandDataTypes, bandNoData);

        } catch (Exception e) {

            throw new CreateBufferException(e);

        }

    }

    private void createBands(int[] bandDataTypes, NoData[] bandNoData) throws BandException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        for (int i = 0; i < bandDataTypes.length; i++) {

            NoData noDataBand = null;

            if (bandNoData != null && i < bandNoData.length) {

                noDataBand = bandNoData[i];

            }

            bands.add(bufferManager.createBand(bandDataTypes[i], this.rows, this.columns,

                noDataBand, this.bandPageManager));

        }

    }

    @Override

    public Statistics getStatistics(SimpleTaskStatus status) {

        if (statistics == null) {

            statistics = new DefaultStatistics(bands);

        }

        if (!statistics.isCalculated()) {

            statistics.calculate(status); // scale ???

        }

        return statistics;

    }

    @Override

    public Iterator<Band> iterator() {

        return bands.iterator();

    }

    @Override

    public void filter(FilterList filterList) {

        this.filters = filterList;

    }

    @Override

    public int getBandCount() {

        return bands.size();

    }

    @Override

    public Band[] getBands() {

        Band[] arrayBands = new Band[bands.size()];

        return bands.toArray(arrayBands);

    }

    @Override

    public int getColumns() {

        return this.columns;

    }

    @Override

    public int getRows() {

        return this.rows;

    }

    @Override

    public Envelope getEnvelope() {

        return this.envelope;

    }

    @Override

    public IProjection getProjection() {

        return this.projection;

    }

    @Override

    public boolean isInside(int cellX, int cellY) {

        return (cellX >= 0 && cellX < this.columns && cellY >= 0 && cellY < this.rows);

    }

    @Override

    public boolean isInside(Point point) {

        if (getEnvelope() == null) {

            return false;

        }

        try {

            return getEnvelope().getGeometry().contains(point);

        } catch (GeometryOperationNotSupportedException | GeometryOperationException e) {

            logger.warn("It could not determine if the point is on the envelope", e);

            return false;

        }

    }

    @Override

    public void addBand(Band band) {

        if(band.getColumns() != this.getColumns() || band.getRows() != this.getRows()){

            throw new IllegalArgumentException(

                "Can not add band to buffer. Band must have the same rows and columns as buffer.");

        }

        this.bands.add(band);

    }

    @Override

    public void setBand(int pos, Band band) throws BandException {

        this.bands.get(pos).copyFrom(band);

    }

    @Override

    public void removeBand(int pos) {

        this.bands.remove(pos);

    }

    @Override

    public Band getBand(int pos) {

        return this.bands.get(pos);

    }

    @Override

    public BandByte getBandByte(int pos) {

        if (this.bands.get(pos).getDataType() != BufferManager.TYPE_BYTE) {

            throw new IllegalArgumentException(String.format("Band in position %1s is type of %2s",

                pos, this.bands.get(pos).getDataType()));

        }

        return (BandByte) this.bands.get(pos);

    }

    @Override

    public BandShort getBandShort(int pos) {

        if (this.bands.get(pos).getDataType() != BufferManager.TYPE_SHORT) {

            throw new IllegalArgumentException(String.format("Band in position %1s is type of %2s",

                pos, this.bands.get(pos).getDataType()));

        }

        return (BandShort) this.bands.get(pos);

    }

    @Override

    public BandInt getBandInt(int pos) {

        if (this.bands.get(pos).getDataType() != BufferManager.TYPE_INT) {

            throw new IllegalArgumentException(String.format("Band in position %1s is type of %2s",

                pos, this.bands.get(pos).getDataType()));

        }

        return (BandInt) this.bands.get(pos);

    }

    @Override

    public BandFloat getBandFloat(int pos) {

        if (this.bands.get(pos).getDataType() != BufferManager.TYPE_FLOAT) {

            throw new IllegalArgumentException(String.format("Band in position %1s is type of %2s",

                pos, this.bands.get(pos).getDataType()));

        }

        return (BandFloat) this.bands.get(pos);

    }

    @Override

    public BandDouble getBandDouble(int pos) {

        if (this.bands.get(pos).getDataType() != BufferManager.TYPE_DOUBLE) {

            throw new IllegalArgumentException(String.format("Band in position %1s is type of %2s",

                pos, this.bands.get(pos).getDataType()));

        }

        return (BandDouble) this.bands.get(pos);

    }

    @Override

    public void switchBands(int[] positions) {

        List<Integer> visited = new ArrayList<Integer>();

        if (positions.length != this.getBandCount()) {

            throw new IllegalArgumentException(

                "Position array length has to be the same as band count");

        }

        for (int i = 0; i < positions.length; i++) {

            Integer position = new Integer(positions[i]);

            if (visited.contains(position)) {

                throw new IllegalArgumentException(

                    String.format(

                        "Position array can not have duplicated bands. Duplicated value: %1s",

                        position));

            }

            visited.add(position);

        }

        List<Band> auxBands = new ArrayList<Band>(bands.size());

        for(int i=0; i < visited.size(); i++){

            auxBands.add(bands.get(visited.get(i)));

        }

        bands = auxBands;

    }

    @Override

    public void switchBands(int pos1, int pos2) {

        Band auxBand = bands.get(pos1);

        bands.set(pos1, bands.get(pos2));

        bands.set(pos2, auxBand);

    }

    @Override

    public Buffer createInterpolated(int rows, int columns, int interpolationMode,

        SimpleTaskStatus status) {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public Buffer convert(ICoordTrans ct, SimpleTaskStatus status) {

//        for (Band band : bands) {

//            band.convert(ct);

//

//        }

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public boolean isPaginated() {

        return bandPageManager != null;

    }

    @Override

    public boolean isReadOnly() {

        if(this.bandPageManager==null){

            return false;

        }

        return !this.bandPageManager.isSupportedSave();

    }

}