Application: gvSIG desktop » gvSIG raster

/* 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 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.ReadException;

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

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

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

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

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

import org.gvsig.fmap.dal.raster.api.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.ViewPort;

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

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

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

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

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

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

import org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation;

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.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

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 {

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

    }

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

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

            throw ex;

        } catch (RuntimeException ex) {

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

            throw ex;

        }

    }

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

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

            throw ex;

        } catch (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);

//        }

        ColorInterpretation colorInterpretation = legend.getColorInterpretation();

        if (colorInterpretation.isPalette()) {

            legend.addColorTableOperation(colorInterpretation, 0);

        } else {

            legend.addLinearStretchEnhancementOperationIfNeeded(colorInterpretation, getRasterStore(), 0);

        }

        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.

     */

    public RasterLegend getLegend(){

        if (legend == null) {

            try {

                initLegend();

            } catch (LegendLayerException e) {

                throw new RuntimeException("Can't initialize legend.", e);

            }

        }

        return legend;

    }

    @Override

    public DataStore getDataStore() {

        return this.store;

    }

    @Override

    public void setDataStore(DataStore dataStore) throws LoadLayerException {

        if (this.store != null) {

            ToolsLocator.getDisposableManager().release(this.store);

            DisposeUtils.disposeQuietly(this.store);

        }

        this.store = (RasterStore) dataStore;

        ToolsLocator.getDisposableManager().bind(dataStore);

        initLegend();

    }

    /**

     * Initializes the legend if it is not initalized yet

     *

     * @throws LegendLayerException

     */

    private void initLegend() throws LegendLayerException {

        RasterLegend legend = null;

        if (this.legend == null) {

            // Should be done like this but must be corrected mapContextManager

            // MapContextManager mapContextManager =

            // MapContextLocator.getMapContextManager();

            // Set the legend

            // IRasterLegend legend = (IRasterLegend)

            // mapContextManager.getLegend(store);

            // Should be moved to mapContextManager when RasterLegend implements

            // ILegend

            if (legend == null) {

                try {

                    legend = (RasterLegend) store.invokeDynMethod(RasterStore.DYNMETHOD_GETLEGEND_NAME, null);

                } catch (DynMethodNotSupportedException e) {

                    logger.debug("This store {} does not provide a legend.", store.getName());

                } catch (DynMethodException e) {

                    logger.error("Can't load the specific legend provided for the store {}.", store.getName(), e);

                }

            }

            if (legend == null) {

                throw new LegendLayerException(this.getName());

            }

            this.setLegend(legend);

        }

    }

    @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.error("Error creating the envelope", e);

                e.printStackTrace();

            }

        }

        // 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, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale)

        throws ReadException {

        if (legend == null) {

            try {

                initLegend();

            } catch (LegendLayerException e) {

                logger.warn("Can't initialize the legend", e);

                return;

            }

            return;

        }

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

        // ColorInterpretation colorInterpretation =

        // legend.getColorInterpretation();

        // String[] renderBands =

        // colorInterpretation.getValues();//.buildRenderBands();

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

        // int band = colorInterpretation.getBand(renderBands[i]);

        // if(band>=0){

        // rasterQuery.addBand(this.store.createBandQuery(band));

        // }

        // }

        RasterSet rasterSet = null;

        try {

            long tini = System.currentTimeMillis();

            // TODO Task status should be used to cancel

            TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

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

            rasterSet = getRasterStore().getRasterSet(rasterQuery);

            // BufferedImage img = rasterSet.getBufferedImage();

            // if (img != null) {

            // try {

            // ImageIO.write(rasterSet.getBufferedImage(), "png32", new

            // File("/tmp/"+rasterSet.getClass().getName()+".png"));

            // } catch (IOException e) {

            // // TODO Auto-generated catch block

            // e.printStackTrace();

            // }

            // }

            if (!rasterSet.isEmpty()) {

                ((RasterLegend) legend).draw(g, rasterSet, viewPort, taskStatus);

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

                    + " milliseconds.");

            }

        } catch (DataException e) {

            this.setAvailable(false);

            this.setError(e);

            throw new ReadException(getName(), e);

        } finally {

            if (rasterSet != null) {

                DisposeUtils.dispose(rasterSet);

                rasterSet = 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<RasterStore>();

        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 {

        DisposeUtils.dispose(this.store);

        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;

    }

    public String getTocImageIcon() {

        return "layer-icon-raster";

    }

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

        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("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();

    }

    private String dataTypeString(int dataType) {

        // FIXME

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

            return "Byte";

        case BufferManager.TYPE_USHORT:

            return "Unsigned short";

        case BufferManager.TYPE_SHORT:

            return "Short";

        case BufferManager.TYPE_INT:

            return "Integer";

        case BufferManager.TYPE_FLOAT:

            return "Float";

        case BufferManager.TYPE_DOUBLE:

            return "Double";

        default:

            throw new IllegalArgumentException();

        }

    }

    @Override

    public String getStatisticsString() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

        this.statistics = getStatistics(null);

        int bandCounter = 0;

        for (StatisticsBand statisticsBand : this.statistics) {

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

            int dataType = statisticsBand.getDataType();

            builder.property().labelkey("_dataType").value(dataTypeString(dataType));

            Long dataCount = statisticsBand.getBandLength();

            builder.property().labelkey("_dataCount").value(dataCount.toString());

            Long noDataValuesCount = statisticsBand.getNoDataValuesCount();

            builder.property().labelkey("_noDataValuesCount").value(noDataValuesCount.toString());

            Double minimum = statisticsBand.getMinimum();

            builder.property().labelkey("_minimum").value(minimum.toString());

            Double maximum = statisticsBand.getMaximum();

            builder.property().labelkey("_maximum").value(maximum.toString());

            Double mean = statisticsBand.getMean();

            builder.property().labelkey("_mean").value(mean.toString());

            Double median = statisticsBand.getMedian();

            builder.property().labelkey("_median").value(median.toString());

            Double secondMin = statisticsBand.getSecondMin();

            builder.property().labelkey("_secondMin").value(secondMin.toString());

            Double secondMax = statisticsBand.getSecondMax();

            builder.property().labelkey("_secondMax").value(secondMax.toString());

            Double variance = statisticsBand.getVariance();

            builder.property().labelkey("_variance").value(variance.toString());

            int bandCounter2 = 0;

            for (StatisticsBand statisticsBand2 : statistics) {

                if (bandCounter != bandCounter2) {

                    Double covariance = statisticsBand.getCovariance(statisticsBand2);

                    builder.property().label(i18nManager.getTranslation("_covariance_with_band") + " " + bandCounter2)

                        .value(covariance.toString());

                }

                bandCounter2++;

            }

            bandCounter++;

        }

        return builder.toString();

    }

    public Statistics getStatistics(SimpleTaskStatus status) {

        if (statistics == null) {

            try {

                statistics = getRasterStore().getRasterSet().getStatistics(status);

            } catch (DataException e) {

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

            }

        }

        return statistics;

    }

    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;

    }

}