Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.raster.impl;

import java.awt.image.BufferedImage;

import java.util.Iterator;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.raster.RasterQuery;

import org.gvsig.fmap.dal.raster.RasterSet;

import org.gvsig.fmap.dal.raster.RasterStore;

import org.gvsig.fmap.dal.raster.exceptions.RasterSetInitializeException;

import org.gvsig.fmap.dal.raster.spi.RasterStoreProvider;

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

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

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

import org.gvsig.tools.dispose.DisposableManager;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.gvsig.tools.visitor.impl.AbstractIndexedVisitable;

/**

 * Implements RasterSet

 *

 * @author dmartinezizquierdo

 *

 */

public class DefaultRasterSet extends AbstractIndexedVisitable implements RasterSet, Observer {

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

    private DefaultRasterStore store;

    protected RasterQuery query;

    protected Buffer buffer;

    // to make it disposable

    private final Object lock = new Object();

    private boolean disposed = false;

    /**

     * Creates a RasterSet with the raster filtered by the query

     *

     * @param store

     * @param query

     * @throws DataException

     */

    public DefaultRasterSet(RasterStore store, RasterQuery query) throws DataException {

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

            ToolsLocator.getDisposableManager().bind(this);

        } else {

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

        }

        DisposableManager disposableManager = ToolsLocator.getDisposableManager();

        disposableManager.bind(store);

        this.store = (DefaultRasterStore) store;

        this.query = query;

        RasterStoreProvider provider = this.store.getProvider();

        try {

            buffer = provider.createBuffer(query);

            // Filter buffer by raster query

            if (buffer!=null && query != null) {

                if (query.getClip() != null) {

                    Buffer clip = buffer.clip(query.getClip());

                    DisposeUtils.dispose(buffer);

                    buffer = clip;

                }

            }

        } catch (BufferException e) {

            throw new RasterSetInitializeException(e);

        }

        this.store.addObserver(this);

    }

    @Override

    public int getBandCount() {

        if (this.buffer != null) {

            return this.buffer.getBandCount();

        }

        return 0;

    }

    @Override

    public Band[] getBands() {

        if (this.buffer != null) {

            return this.buffer.getBands();

        }

        return null;

    }

    @Override

    public int getColumns() {

        if (this.buffer != null) {

            return this.buffer.getColumns();

        }

        return 0;

    }

    @Override

    public int getRows() {

        if (this.buffer != null) {

            return this.buffer.getRows();

        }

        return 0;

    }

    @Override

    public boolean areAllBandsOfTheSameType() {

        if (this.buffer != null) {

            return this.buffer.areAllBandsOfTheSameType();

        }

        return true;

    }

    @Override

    public Envelope getEnvelope() throws LocatorException, CreateEnvelopeException {

        if (this.buffer != null) {

            return this.buffer.getEnvelope();

        }

        return GeometryLocator.getGeometryManager().createEnvelope(SUBTYPES.GEOM2D);

    }

    @Override

    public IProjection getProjection() {

        if (this.buffer != null) {

            return this.buffer.getProjection();

        }

        return null; // /OJO

    }

    @Override

    public boolean isInside(int cellX, int cellY) {

        if (this.buffer != null) {

            return this.buffer.isInside(cellX, cellY);

        }

        return false;

    }

    @Override

    public boolean isInside(Point point) {

        if (this.buffer != null) {

            return this.buffer.isInside(point);

        }

        return false;

    }

    @Override

    public void addBand(Band band) {

        if (this.buffer != null) {

            this.buffer.addBand(band);

        }

    }

    @Override

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

        if (this.buffer != null) {

            this.buffer.setBand(pos, band);

        }

    }

    @Override

    public void removeBand(int pos) {

        if (this.buffer != null) {

            this.buffer.removeBand(pos);

        }

    }

    @Override

    public Band getBand(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBand(pos);

        }

        return null;

    }

    @Override

    public BandByte getBandByte(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBandByte(pos);

        }

        return null;

    }

    @Override

    public BandShort getBandShort(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBandShort(pos);

        }

        return null;

    }

    @Override

    public BandInt getBandInt(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBandInt(pos);

        }

        return null;

    }

    @Override

    public BandFloat getBandFloat(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBandFloat(pos);

        }

        return null;

    }

    @Override

    public BandDouble getBandDouble(int pos) {

        if (this.buffer != null) {

            return this.buffer.getBandDouble(pos);

        }

        return null;

    }

    @Override

    public void switchBands(int[] positions) {

        if (this.buffer != null) {

            this.buffer.switchBands(positions);

        }

    }

    @Override

    public void switchBands(int pos1, int pos2) {

        if (this.buffer != null) {

            this.buffer.switchBands(pos1, pos2);

        }

    }

    @Override

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

        throws LocatorException, BufferException {

        if (this.buffer != null) {

            return this.buffer.createInterpolated(rows, columns, interpolationMode, status);

        }

        return null;

    }

    @Override

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

        if (this.buffer != null) {

            return this.buffer.convert(ct, status);

        }

        return null;

    }

    @Override

    public int[] getBandTypes() {

        if (this.buffer != null) {

            return this.buffer.getBandTypes();

        }

        return null;

    }

    @Override

    public NoData[] getBandNoData() {

        if (this.buffer != null) {

            return this.buffer.getBandNoData();

        }

        return null;

    }

    @Override

    public Buffer clip(Envelope envelope) throws BufferException {

        if (this.buffer != null) {

            return this.buffer.clip(envelope);

        }

        return null;

    }

    @Override

    public double getPixelSizeX() {

        if (this.buffer != null) {

            return this.buffer.getPixelSizeX();

        }

        return Double.NaN;

    }

    @Override

    public double getPixelSizeY() {

        if (this.buffer != null) {

            return this.buffer.getPixelSizeY();

        }

        return Double.NaN;

    }

    @Override

    public Statistics getStatistics(SimpleTaskStatus status) {

        if (this.buffer != null) {

            return this.buffer.getStatistics(status);

        }

        return null;

    }

    @Override

    public void addObserver(Observer o) {

        if (this.buffer != null) {

            this.buffer.addObserver(o);

        }

    }

    @Override

    public void deleteObserver(Observer o) {

        if (this.buffer != null) {

            this.buffer.deleteObserver(o);

        }

    }

    @Override

    public void deleteObservers() {

        if (this.buffer != null) {

            this.buffer.deleteObservers();

        }

    }

    @Override

    public Iterator<Band> iterator() {

        if (this.buffer != null) {

            return this.buffer.iterator();

        }

        return null;

    }

    @Override

    public boolean isFromStore(DataStore store) {

        return this.store.equals(store);

    }

    @Override

    public void update(Observable observable, Object notification) {

        // Do nothing

    }

    @Override

    protected void doAccept(Visitor visitor, long firstValueIndex) throws VisitCanceledException, BaseException {

        if (this.buffer != null) {

            DefaultRasterKernel kernel = new DefaultRasterKernel(this.buffer);

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

                for (int column = 0; column < this.buffer.getColumns(); column++) {

                    kernel.set(row, column);

                    visitor.visit(kernel);

                }

            }

        }

    }

    @Override

    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.

     *

     * @throws org.gvsig.tools.exception.BaseException

     * @see #dispose()

     */

    public void doDispose() throws BaseException {

        DisposeUtils.dispose(store);

        store = null;

        DisposeUtils.dispose(buffer);

        buffer = null;

        query = null;

    }

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

    }

    @Override

    public BufferedImage getBufferedImage() {

        if (this.buffer != null) {

            return buffer.getBufferedImage();

        }

        return null;

    }

    @Override

    public boolean isEmpty() {

        return buffer==null;

    }

    @Override

    public BufferDimensions getDimensions() {

        return buffer.getDimensions();

    }

    @Override

    public BandInfo[] getBandsInfo() {

        if (this.buffer != null) {

            return this.buffer.getBandsInfo();

        }

        return null;

    }

}