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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractBuffer extends BaseWeakReferencingObservable implements Buffer {

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

    protected List<Band> bands;

    protected int rows;

    protected int columns;

    protected FilterList filters;

    protected Envelope envelope;

    protected IProjection projection;

    protected Statistics statistics;

    private Double pixelSizeX = null;

    private Double pixelSizeY = null;

//    // to make 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 }));

            }

        }

    }

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

        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", 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;

        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 {

            if (rows == getRows() && columns == getColumns()) {

                return (Buffer) this.clone();

            }

            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 (CloneNotSupportedException | 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.envelope.intersects(envelope)){

            return null;

        }

        try {

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

        } catch (LocatorException | BufferException e) {

            throw new BufferException(e);

        }

    }

    public double getPixelSizeX(){

        if(pixelSizeX == null){

            pixelSizeX = this.getEnvelope().getLength(0)/this.getColumns();

        }

        return pixelSizeX.doubleValue();

    }

    public double getPixelSizeY(){

        if(pixelSizeY == null){

            pixelSizeY = this.getEnvelope().getLength(1)/this.getRows();

        }

        return pixelSizeY.doubleValue();

    }

//    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) {

//                        LOG.error("Error performing dispose", ex);

//                    }

//                    disposed = true;

//                }

//            }

//        }

//    }

//

//    @Override

//    public void doDispose() {

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

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

//            band.dispose();

//        }

//        envelope = null;

//        projection = null;

//        //TODO: ?FilterList Disposable?

//        filters = null;

//        //TODO: ?Statistics Disposable?

//        statistics = null;

//

//        pixelSizeX = null;

//        pixelSizeY = null;

//    }

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

        logger.info("AbstractBuffer with rows = "+rows+" columns = "+columns+" CLEANED");

    }

}