Application: gvSIG desktop » gvSIG raster

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

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

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.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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.BandInfo;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractBuffer extends BaseWeakReferencingObservable implements Buffer {

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

    protected List<Band> bands;

//    protected FilterList filters;

    protected IProjection projection;

    protected Statistics statistics;

    protected BufferDimensions dimensions = null;

    // to make it disposable

    private final Object lock = new Object();

    private boolean disposed = false;

    /**

     *

     */

    public AbstractBuffer() {

        if(ToolsLocator.getDisposableManager() != null) {

            ToolsLocator.getDisposableManager().bind(this);

        } else {

            logger.warn("Can't retrieve the disposable manager,");

        }

    }

    @Override

    public Statistics getStatistics(SimpleTaskStatus status) {

        if (statistics == null) {

            statistics = new DefaultStatistics(bands);

            // this.addObserver(statistics);

        }

        if (!statistics.isCalculated()) {

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

        }

        return statistics;

    }

    @Override

    public Iterator<Band> iterator() {

        return bands.iterator();

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (notification instanceof BandNotification && observable instanceof Band) {

            Notification bandNotification = (Notification) notification;

            if (bandNotification.getType().equals(BandNotification.COPY_FROM)

                || bandNotification.getType().equals(BandNotification.FILL)

                || bandNotification.getType().equals(BandNotification.PUT_ROW)

                || bandNotification.getType().equals(BandNotification.SET)) {

                this.statistics = null;

                this.notifyObservers(new DefaultBufferNotification(BufferNotification.CHANGE_BAND,

                    new Object[] { observable }));

            } else if (bandNotification.getType().equals(BandNotification.LOADED_PAGE)){

                this.notifyObservers(new DefaultBufferNotification(BufferNotification.LOADED_PAGE,

                    new Object[] { this }));

            }

        }

    }

//    @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.dimensions.getColumns();

    }

    @Override

    public int getRows() {

        return this.dimensions.getRows();

    }

    @Override

    public Envelope getEnvelope() {

        return this.dimensions.getEnvelope();

    }

    @Override

    public BufferDimensions getDimensions() {

        return this.dimensions;

    }

    @Override

    public IProjection getProjection() {

        return this.projection;

    }

    @Override

    public boolean isInside(int cellX, int cellY) {

        return (cellX >= 0 && cellX < this.getColumns() && cellY >= 0 && cellY < this.getRows());

    }

    @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);

        band.addObserver(this);

        this.statistics = null;

        this.notifyObservers(new DefaultBufferNotification(BufferNotification.ADD_BAND, new Object[] { band }));

    }

    @Override

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

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

        this.statistics = null;

        this.notifyObservers(new DefaultBufferNotification(BufferNotification.SET_BAND, new Object[] { pos, band }));

    }

    @Override

    public void removeBand(int pos) {

        Band band = this.bands.get(pos);

        band.deleteObserver(this);

        this.bands.remove(pos);

        this.statistics = null;

        this.notifyObservers(new DefaultBufferNotification(BufferNotification.REMOVE_BAND, new Object[] { 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, byte expected", 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, short expected", 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, int expected", 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, float expected", 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, double expected", 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;

        this.statistics = null;

        this.notifyObservers(new DefaultBufferNotification(BufferNotification.SWITCH_BAND, new Object[] { positions }));

    }

    @Override

    public void switchBands(int pos1, int pos2) {

        Band auxBand = bands.get(pos1);

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

        bands.set(pos2, auxBand);

        this.statistics = null;

        this.notifyObservers(new DefaultBufferNotification(BufferNotification.SWITCH_BAND, new Object[] { pos1, pos2 }));

    }

    @Override

    public Buffer createInterpolated(int rows, int columns, int interpolationMode, SimpleTaskStatus status)

        throws BufferException {

        if(rows==0 || columns==0){

            return null;

        }

        try {

            Buffer target =

                BufferLocator.getBufferManager().createBuffer(rows, columns, this.getBandTypes(),

                    this.getBandNoData(), this.getProjection(), this.getEnvelope(), null);

            BufferInterpolation interp = new BufferInterpolation();

            switch (interpolationMode) {

            case Buffer.INTERPOLATION_NearestNeighbour:

                interp.nearestNeighbourInterpolation(this, target, status);

                break;

            case Buffer.INTERPOLATION_Bilinear:

                interp.bilinearInterpolation(this, target, status);

                break;

            case Buffer.INTERPOLATION_InverseDistance:

                interp.inverseDistanceInterpolation(this, target, status);

                break;

            case Buffer.INTERPOLATION_BicubicSpline:

                interp.bicubicSplineInterpolation(this, target, status);

                break;

            case Buffer.INTERPOLATION_BSpline:

                interp.bSplineInterpolation(this, target, status);

                break;

            }

            return target;

        } catch (LocatorException e) {

            throw new BufferException(e);

        }

    }

    @Override

    public Buffer convert(ICoordTrans ct, SimpleTaskStatus status) throws BufferException {

        if (this.getEnvelope() == null) {

            throw new IllegalStateException("Buffer envelope is null. A buffer allways has to have envelope");

        }

        boolean isMyStatus = false;

        if (status == null) {

            status =

                ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(

                    String.format("Projecting buffer from %1s to %2s", ct.getPOrig().getAbrev(), ct.getPDest()

                        .getAbrev()));

            status.add();

            isMyStatus = true;

        } else {

            status.push();

        }

        Envelope projectedBufferEnvelope = this.getEnvelope().convert(ct);

        // Get size of new buffer

        double[] newsize = getSize(this.getEnvelope(), projectedBufferEnvelope, this.getColumns(), this.getRows());

        int projectedBufferColumns = (int) newsize[0];

        int projectedBufferRows = (int) newsize[1];

        int[] bandDataTypes = this.getBandTypes();

        NoData[] bandNoData = this.getBandNoData();

        status.message("Creating projected buffer");

        Buffer projectedBuffer =

            BufferLocator.getBufferManager().createBuffer(projectedBufferRows, projectedBufferColumns, bandDataTypes,

                bandNoData, ct.getPDest(), projectedBufferEnvelope);

        // This affine transform allow us to convert pixel to coordinate and inverse

        AffineTransform bufferAf = calculateAffineTransform(this.getEnvelope(), this.getRows(), this.getColumns());

        AffineTransform projectedBufferAf =

            calculateAffineTransform(projectedBufferEnvelope, projectedBufferRows, projectedBufferColumns);

        ICoordTrans invertedCt = ct.getInverted();

        AffineTransform inverseBufferAf;

        try {

            inverseBufferAf = bufferAf.createInverse();

        } catch (NoninvertibleTransformException e1) {

            status.abort();

            logger.error("Can not create inverse transformation of {}", bufferAf);

            throw new BufferException(e1);

        }

        status.setRangeOfValues(0,

            projectedBuffer.getRows() * projectedBuffer.getColumns() * projectedBuffer.getBandCount());

        status.message("Projecting buffer");

        Point point;

        try {

            point = (Point) GeometryLocator.getGeometryManager().create(TYPES.POINT, SUBTYPES.GEOM2D);

        } catch (CreateGeometryException | LocatorException e1) {

            status.abort();

            logger.error("Can not create point geometry to project buffer");

           throw new BufferException(e1);

        }

        for (int row = 0; row < projectedBuffer.getRows(); row++) {

            if (status.isCancellationRequested()) {

                status.cancel();

                return projectedBuffer;

            }

            for (int col = 0; col < projectedBuffer.getColumns(); col++) {

                point.setX(col);

                point.setY(row);

                point.transform(projectedBufferAf); // projected buffer

                                                    // pixel to world point

                                                    // (target projection)

                point.reProject(invertedCt); // projected world point

                                             // to world point (source

                                             // projection)

                point.transform(inverseBufferAf); // world point to

                                                  // pixel source

                                                  // buffer

                double floorPointX = Math.floor(point.getX());

                double floorPointY = Math.floor(point.getY());

                boolean isValidPoint =

                    point.getX() >= 0 && floorPointX < this.getColumns() && point.getY() >= 0

                        && floorPointY < this.getRows();

                for (int k = 0; k < this.getBandCount(); k++) {

                    status.setCurValue(row * col * k);

                    Band band = this.bands.get(k);

                    Number value = null;

                    if (isValidPoint) {

                        value = (Number) band.get((int) floorPointY, (int) floorPointX);

                    } else if (band.getNoData().isDefined()) {

                        value = band.getNoData().getValue();

                    } else {

                        continue;

                    }

                    Band projectedBand = projectedBuffer.getBand(k);

                    int dataType = projectedBand.getDataType();

                    switch (dataType) {

                    case BufferManager.TYPE_BYTE:

                        projectedBand.set(row, col, value.byteValue());

                        break;

                    case BufferManager.TYPE_SHORT:

                        projectedBand.set(row, col, value.shortValue());

                        break;

                    case BufferManager.TYPE_INT:

                        projectedBand.set(row, col, value.intValue());

                        break;

                    case BufferManager.TYPE_FLOAT:

                        projectedBand.set(row, col, value.floatValue());

                        break;

                    case BufferManager.TYPE_DOUBLE:

                        projectedBand.set(row, col, value.doubleValue());

                        break;

                    default:

                        break;

                    }

                }

            }

        }

        if (isMyStatus) {

            status.terminate();

        } else {

            status.pop();

        }

        return projectedBuffer;

    }

    private double[] getSize(Envelope envelope, Envelope projectedEnvelope, int p1x, int p1y) {

        double sumSideOldBBox = envelope.getLength(0) + envelope.getLength(1);

        double sumSideNewBBox = projectedEnvelope.getLength(0) + projectedEnvelope.getLength(1);

        double d1x = (envelope.getLength(0) * 100) / sumSideOldBBox;

        double d1y = (envelope.getLength(1) * 100) / sumSideOldBBox;

        double d2x = (projectedEnvelope.getLength(0) * 100) / sumSideNewBBox;

        double d2y = (projectedEnvelope.getLength(1) * 100) / sumSideNewBBox;

        double p2y = (p1y * d2y) / d1y;

        double p2x = (p1x * d2x) / d1x;

        double newCellSizeX = projectedEnvelope.getLength(0) / p2x;

        double newCellSizeY= projectedEnvelope.getLength(1) / p2y;

        return new double[] { Math.round(p2x), Math.round(p2y), newCellSizeX, newCellSizeY };

    }

    private AffineTransform calculateAffineTransform(Envelope projectedBufferEnvelope, int projectedBufferRows,

        int projectedBufferColumns) {

        double cellSizeX = projectedBufferEnvelope.getLength(0) / projectedBufferColumns;

        double cellSizeY = projectedBufferEnvelope.getLength(1) / projectedBufferRows;

        return new AffineTransform(cellSizeX, 0d, 0d, -cellSizeY, projectedBufferEnvelope.getMinimum(0),

            projectedBufferEnvelope.getMaximum(1));

    }

    public int[] getBandTypes() {

        int[] bandDataTypes = new int[this.getBandCount()];

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

            bandDataTypes[i] = this.bands.get(i).getDataType();

        }

        return bandDataTypes;

    }

    public NoData[] getBandNoData() {

        NoData[] bandNoData = new NoData[this.getBandCount()];

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

            bandNoData[i] = this.bands.get(i).getNoData();

        }

        return bandNoData;

    }

    @Override

    public Buffer clip(Envelope envelope) throws BufferException {

        if(!this.getEnvelope().intersects(envelope)) {

            return null;

        }

        try {

            if(this.getEnvelope().getGeometry().intersection(envelope.getGeometry())==null) {

                return null;

            }

        } catch (GeometryOperationNotSupportedException | GeometryOperationException e1) {

            logger.warn("Can't get intersection between two envelopes", e1);

            return null;

        }

        try {

            return BufferLocator.getBufferManager().createClippedBuffer(this, envelope);

        } catch (LocatorException | BufferException e) {

            throw new BufferException(e);

        }

    }

    public double getPixelSizeX(){

        return this.dimensions.getPixelSizeX();

    }

    public double getPixelSizeY(){

        return this.dimensions.getPixelSizeY();

    }

    public final void dispose() {

        synchronized (lock) {

            // Check if we have already been disposed, and don't do it again

            if (!disposed) {

                if ( ToolsLocator.getDisposableManager().release(this) ) {

                    try {

                        doDispose();

                    } catch (BaseException ex) {

                        logger.error("Error performing dispose", ex);

                    }

                    disposed = true;

                }

            }

        }

    }

    /**

     * Internal implementation for the {@link #dispose()} method.

     *

     * @see #dispose()

     */

    public void doDispose() throws BaseException {

        for (Iterator iterator = bands.iterator(); iterator.hasNext();) {

            Band band = (Band) iterator.next();

            DisposeUtils.dispose(band);

        }

        bands.removeAll(bands);

        projection = null;

        //TODO: ?FilterList Disposable?

//        filters = null;

        //TODO: ?Statistics Disposable?

        statistics = null;

        dimensions = null;

    }

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

    }

    @Override

    public BandInfo[] getBandsInfo() {

        BandInfo[] bandsInfo = new BandInfo[this.bands.size()];

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

            bandsInfo[i] = this.bands.get(i).getBandInfo();

        }

        return bandsInfo;

    }

}