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.mapcontext.raster.impl;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.util.List;

import java.util.Observable;

import java.util.Observer;

import java.util.Set;

import java.util.TreeSet;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.cresques.cts.ICoordTrans;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLyrDefault;

import org.gvsig.fmap.mapcontext.layers.LayerInformationBuilder;

import org.gvsig.fmap.mapcontext.raster.api.RasterLayer;

import org.gvsig.fmap.mapcontext.raster.api.legend.RasterLegendEvent;

import org.gvsig.fmap.mapcontext.raster.api.legend.listeners.RasterLegendChangedListener;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendClearEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.metadata.exceptions.MetadataException;

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

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

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

import org.gvsig.raster.lib.legend.api.RasterLegend;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.util.Callable;

/**

 * Capa b?sica Raster.

 *

 */

public class DefaultRasterLayer extends FLyrDefault implements RasterLayer, RasterLegendChangedListener, Observer {

    final static private org.slf4j.Logger logger = LoggerFactory.getLogger(DefaultRasterLayer.class);

    private RasterStore store;

    private RasterLegend legend;

    // private Cancellable cancel;

    private RasterQuery baseQuery;

    private Statistics statistics;

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            DynStruct definition =

                manager.addDefinition(DefaultRasterLayer.class, "DefaultRasterLayer",

                    "DefaultRasterLayer Persistence definition", null, null);

            definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, "FLyrDefault");

            definition.addDynFieldObject("legend").setClassOfValue(RasterLegend.class).setMandatory(true);

            definition.addDynFieldObject("store").setClassOfValue(RasterStore.class).setMandatory(true);

            definition.addDynFieldObject("baseQuery").setClassOfValue(RasterQuery.class).setMandatory(false);

            return Boolean.TRUE;

        }

    }

    /**

     * Creates a new DefaultRasterLayer

     *

     * @throws LoadLayerException

     */

    public DefaultRasterLayer() throws LoadLayerException {

        super();

    }

    /**

     * Creates a new DefaultRasterLayer

     *

     * @param store

     * @param legend

     */

    public DefaultRasterLayer(RasterStore store, RasterLegend legend) {

        super();

        ToolsLocator.getDisposableManager().bind(store);

        this.store = store;

        this.setLegend(legend);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        try {

            super.saveToState(state);

            state.set("store", (Persistent) this.store);

            state.set("legend", (Persistent) this.legend);

            state.set("baseQuery", (Persistent) this.baseQuery);

        } catch (PersistenceException | RuntimeException ex) {

            logger.warn("Can't save to persistent state the layer '" + this.getName() + "'.");

            throw ex;

        }

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        try {

            super.loadFromState(state);

            this.store = (RasterStore) state.get("store");

            this.legend = (RasterLegend) state.get("legend");

            this.baseQuery = (RasterQuery) state.get("baseQuery");

        } catch (PersistenceException | RuntimeException ex) {

            logger.warn("Can't load from persietent state the layer '" + this.getName() + "'.");

            throw ex;

        }

    }

    private void setLegend(RasterLegend legend) {

        if (this.legend == legend) {

            return;

        }

        if (this.legend != null && this.legend.equals(legend)) {

            return;

        }

        RasterLegend oldLegend = this.legend;

        if (oldLegend != null) {

             oldLegend.removeLegendListener( this);

//             oldLegend.deleteDrawingObserver(this);

        }

        this.legend = legend;

//        if (this.legend != null) {

//             this.legend.addDrawingObserver(this);

//             this.legend.addLegendListener( this);

//        }

        this.legend.addLegendListener(this);

        LegendChangedEvent e = LegendChangedEvent.createLegendChangedEvent(oldLegend, this.legend);

        // FIXME: cuando se arregle LegendChangeEvent para que admita capas

        // raster (y no solo las ClassifiableVectorial) descomentarizar la siguiente l?nea

        // e.setLayer(this);

        updateDrawVersion();

        callLegendChanged(e);

    }

    /**

     * Devuelve la Leyenda de la capa.

     *

     * @return Leyenda.

     */

    @Override

    public RasterLegend getLegend(){

        if (legend == null) {

            MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

            RasterLegend theLegend = (RasterLegend) mapContextManager.getLegend(store);

            this.setLegend(theLegend);

      }

        return legend;

    }

    @Override

    public DataStore getDataStore() {

        return this.store;

    }

    @Override

    public void setDataStore(DataStore dataStore) throws LoadLayerException {

        if (this.store != null) {

            DisposeUtils.disposeQuietly(this.store);

        }

        this.store = (RasterStore) dataStore;

        ToolsLocator.getDisposableManager().bind(dataStore);

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        RasterLegend theLegend = (RasterLegend) mapContextManager.getLegend(store);

        this.setLegend(theLegend);

    }

    @Override

    public Envelope getFullEnvelope() throws ReadException {

        Envelope rAux;

        try {

            rAux = getRasterStore().getEnvelope();

        } catch (BaseException e) {

            throw new ReadException(getName(), e);

        }

        // Esto es para cuando se crea una capa nueva con el fullExtent de ancho

        // y alto 0.

        if (rAux == null || rAux.isEmpty() || rAux.getMaximum(0) - rAux.getMinimum(0) == 0

            && rAux.getMaximum(1) - rAux.getMinimum(1) == 0) {

            try {

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                rAux = geomManager.createEnvelope(0, 0, 90, 90, SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                logger.warn("Error creating the envelope", e);

            }

        }

        // Si existe reproyecci?n, reproyectar el extent

        ICoordTrans ct = getCoordTrans();

        if (ct != null) {

            rAux = rAux.convert(ct);

        }

        return rAux;

    }

    @Override

    public void draw(BufferedImage image, final Graphics2D g, final ViewPort viewPort, Cancellable cancel, double scale)

        throws ReadException {

        if (!this.isWithinScale(scale)) {

            return;

        }

        if (cancel.isCanceled()) {

            return;

        }

        RasterQuery rasterQuery = createRasterQuery();

        Envelope reprojectedViewPortEnvelope = (Envelope) viewPort.getAdjustedEnvelope(); // .getEnvelope();

        ICoordTrans ct = getCoordTrans();

        if (ct != null) {

            try {

                reprojectedViewPortEnvelope = (Envelope) reprojectedViewPortEnvelope.clone();

                reprojectedViewPortEnvelope = reprojectedViewPortEnvelope.convert(ct.getInverted());

            } catch (CloneNotSupportedException e) {

                this.setAvailable(false);

                this.setError(e);

                throw new ReadException(getName(), e);

            }

        }

        double pixelSize = reprojectedViewPortEnvelope.getLength(0) / (double) viewPort.getImageWidth();

        rasterQuery.setPixelSize(pixelSize);

        rasterQuery.setClip(reprojectedViewPortEnvelope);

        RasterSet rasterSet = null;

        SimpleTaskStatus taskStatus = null;

        try {

            long tini = System.currentTimeMillis();

            // TODO Task status should be used to cancel

            TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

            taskStatus = manager.createDefaultSimpleTaskStatus("Draw " + getDataStore().getName());

            taskStatus.setAutoremove(true);

            taskStatus.add();

            rasterSet = getRasterStore().getRasterSet(rasterQuery);

            if (!rasterSet.isEmpty()) {

                getLegend().draw(g, rasterSet, viewPort, taskStatus);

                logger.debug("Layer " + this.getName() + " drawn in " + (System.currentTimeMillis() - tini)

                    + " milliseconds.");

            }

        } catch (DataException e) {

            if( taskStatus!=null ) {

                taskStatus.abort();

                taskStatus = null;

            }

            this.setAvailable(false);

            this.setError(e);

            throw new ReadException(getName(), e);

        } finally {

            if (rasterSet != null) {

                DisposeUtils.dispose(rasterSet);

                rasterSet = null;

            }

            if( taskStatus!=null ) {

                taskStatus.terminate();

                taskStatus = null;

            }

        }

    }

    @Override

    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, PrintAttributes properties)

        throws ReadException {

        // TODO legend doesn't have print method

        throw new UnsupportedOperationException();

    }

    @Override

    public Set<RasterStore> getMetadataChildren() throws MetadataException {

        Set<RasterStore> ret = new TreeSet<>();

        ret.add(this.store);

        return ret;

    }

    @Override

    public Object getMetadataID() throws MetadataException {

        return "Layer(" + this.getName() + "):" + this.store.getMetadataID();

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (observable.equals(this.store)) {

            if (notification instanceof RasterStoreNotification) {

                RasterStoreNotification event = (RasterStoreNotification) notification;

                if (event.getType() == RasterStoreNotification.AFTER_REFRESH

                    || event.getType() == RasterStoreNotification.SELECTION_CHANGE) {

                    this.updateDrawVersion();

                } else if (event.getType() == RasterStoreNotification.RESOURCE_CHANGED) {

                    this.setAvailable(false);

                }

            }

        }

    }

    @Override

    public RasterStore getRasterStore() {

        return this.store;

    }

    @Override

    public void setBaseQuery(RasterQuery baseQuery) {

        this.baseQuery = baseQuery;

    }

    @Override

    public RasterQuery getBaseQuery() {

        return this.baseQuery;

    }

    @Override

    public RasterQuery createRasterQuery() {

        if (this.baseQuery == null) {

            return this.getRasterStore().createRasterQuery();

        }

        try {

            return (RasterQuery) baseQuery.clone();

        } catch (CloneNotSupportedException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        logger.debug("Dispose DefaultRasterLayer '"+(this.getDataStore()==null?"NULL":this.getDataStore().getFullName()+"'"));

        DisposeUtils.dispose(this.store);

        this.layerListeners.clear();

        this.store = null;

        this.legend = null;

        this.baseQuery = null;

    }

    @Override

    public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel) throws LoadLayerException, DataException {

        return getInfo(p, tolerance, cancel, true);

    }

    @Override

    public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel, boolean fast) throws LoadLayerException,

        DataException {

        Point2D infop = new Point2D.Double(p.x, p.y);

        org.gvsig.fmap.geom.primitive.Point pReal = this.getMapContext().getViewPort().convertToMapPoint(infop);

        // TODO:

        return null;

    }

    @Override

    public DynObjectSet getInfo(org.gvsig.fmap.geom.primitive.Point p, double tolerance) throws LoadLayerException,

        DataException {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public String getTocImageIcon() {

        //FIXME: Subir esto a la clase abstracta

        return MapContextLocator.getMapContextManager().getIconLayer(this.getDataStore());

    }

    @Override

    public void setLegend(ILegend legend) {

        if (legend instanceof RasterLegend) {

            setLegend((RasterLegend) legend);

        } else {

            throw new IllegalArgumentException("The legend isn't a RasterLegend.");

        }

    }

    @Override

    public String getInfoString() {

        RasterStore rasterStore = this.getRasterStore();

        Envelope envelope = null;

        try {

            envelope = rasterStore.getEnvelope();

        } catch (LocatorException | DataException | CreateEnvelopeException e) {

        }

        int bands = rasterStore.getBands();

        int rows = -1;

        int columns = -1;

        String pixelSize = "-/-";

        try {

            BufferDimensions dimensions = rasterStore.getDimensions();

            rows = dimensions.getRows();

            columns = dimensions.getColumns();

            pixelSize = String.format("%.3f/%.3f", dimensions.getPixelSizeX(), dimensions.getPixelSizeY());

        } catch (InitializeException ex) {

        }

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        LayerInformationBuilder builder = MapContextLocator.getMapContextManager().createLayerInformationBuilder();

        builder.title().labelkey("Data_source");

        builder.property().labelkey("Source_type").value(store.getProviderName());

        builder.property().labelkey("origen").value(store.getFullName());

        if (store.getParameters() instanceof FilesystemStoreParameters) {

            File f = ((FilesystemStoreParameters) (store.getParameters())).getFile();

            if (f != null) {

                builder.property().labelkey("size").value("%d bytes", f.length());

            }

        }

        builder.property().labelkey("_bands").value("%d", bands);

        builder.property().labelkey("_rows").value("%d", rows);

        builder.property().labelkey("_columns").value("%d", columns);

        builder.property().labelkey("_pixel_size").value("%s", pixelSize);

        builder.property().labelkey("transparency").value("%d", this.getTransparency());

        builder.title().labelkey("_Coordenadas_geograficas");

        builder.envelope().value(envelope);

        builder.title().labelkey("_Projection");

        builder.property().value(this.getProjection());

        builder.text().asWKT(this.getProjection());

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

            builder.title().labelkey(i18nManager.getTranslation("_band") + " " + i);

            BandDescriptor bandDescriptor = rasterStore.getBandDescriptor(i);

            builder.property().labelkey("_name").value(bandDescriptor.getName());

            builder.property().labelkey("_description").value(bandDescriptor.getDescription());

            builder.property().labelkey("_dataType")

                .value(BufferLocator.getBufferManager().getTypeName(bandDescriptor.getDataType()));

            if (bandDescriptor.getNoData() != null) {

                builder.property().labelkey("_noData").value(bandDescriptor.getNoData().toString());

            } else {

                builder.property().labelkey("_noData").value(i18nManager.getTranslation("_null"));

            }

            for (BandAttributeDescriptor bandAttributeDescriptor : bandDescriptor) {

                builder.property().labelkey("_name").value(bandAttributeDescriptor.getName());

                builder.property().labelkey("_description").value(bandAttributeDescriptor.getDescription());

                builder.property().labelkey("_units").value(bandAttributeDescriptor.getUnits());

                builder.title().labelkey("_values");

                List<Object> attributeValues = bandAttributeDescriptor.getAvailableValues();

                for (Object value : attributeValues) {

                    if (value != null) {

                        builder.property().labelkey("_units").value(bandAttributeDescriptor.getUnits());

                    } else {

                        builder.property().labelkey("_units").value(bandAttributeDescriptor.getUnits());

                    }

                }

            }

        }

        return builder.toString();

    }

    @Override

    public Statistics getStatistics(SimpleTaskStatus status) {

        if (statistics == null) {

            RasterSet rasterSet = null;

            try {

                rasterSet = getRasterStore().getRasterSet();

                statistics = rasterSet.getStatistics(status);

            } catch (DataException e) {

                logger.warn("Can't get layer's statistics", e);

            } finally {

                DisposeUtils.dispose(rasterSet);

            }

        }

        return statistics;

    }

    @Override

    public void recalculateStatistics() {

        this.statistics = null;

    }

    @Override

    public FLayer cloneLayer() throws Exception {

        RasterLegend clonedLegend = (RasterLegend)this.legend.cloneLegend();

        DefaultRasterLayer cloned = new DefaultRasterLayer(this.store, clonedLegend);

        cloned.setName(this.getName());

        cloned.setProjection(this.getProjection());

        return cloned;

    }

    @Override

    public boolean symbolChanged(SymbolLegendEvent e) {

        //FIXME: Remove when fixed hierarchy of legend events

        throw new UnsupportedOperationException("There aren't any symbols in a raster legend.");

    }

    @Override

    public void legendCleared(LegendClearEvent event) {

        //FIXME: Remove when fixed hierarchy of legend events

        throw new UnsupportedOperationException("Can't clear a raster legend.");

    }

    @Override

    public boolean colorInterpretationChanged(RasterLegendEvent e) {

        this.updateDrawVersion();

        LegendChangedEvent ev = LegendChangedEvent.createLegendChangedEvent(legend, e);

        this.callLegendChanged(ev);

        return true;

    }

    @Override

    public boolean operationListChanged(RasterLegendEvent e) {

        this.updateDrawVersion();

        LegendChangedEvent ev = LegendChangedEvent.createLegendChangedEvent(legend, e);

        this.callLegendChanged(ev);

        return true;

    }

}