Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.raster.impl.store;

import java.io.File;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.cresques.cts.ICoordTrans;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.BandList;

import org.gvsig.fmap.dal.coverage.datastruct.DatasetBand;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.datastruct.GeoPointList;

import org.gvsig.fmap.dal.coverage.exception.BandNotFoundInListException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.exception.RmfSerializerException;

import org.gvsig.fmap.dal.coverage.grid.render.Render;

import org.gvsig.fmap.dal.coverage.process.vector.Vectorization;

import org.gvsig.fmap.dal.coverage.store.RasterDataServerExplorer;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterFileStoreParameters;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.Metadata;

import org.gvsig.fmap.dal.coverage.store.props.TimeSeries;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.Resource;

import org.gvsig.fmap.dal.spi.DataStoreInitializer;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.buffer.DefaultRasterQuery;

import org.gvsig.raster.impl.datastruct.BandListImpl;

import org.gvsig.raster.impl.datastruct.DatasetBandImpl;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.grid.render.DefaultRender;

import org.gvsig.raster.impl.process.vector.PotraceVectorization;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.RemoteRasterProvider;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

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

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

import org.gvsig.tools.exception.BaseException;

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

import org.gvsig.tools.undo.command.Command;

import org.gvsig.tools.visitor.Visitor;

/**

 * Default implementation for RasterDataSource

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public abstract class AbstractRasterDataStore extends AbstractDisposable 

        implements RasterDataStore, CoverageStoreProviderServices, QueryableRaster, DataStoreInitializer {

        public static final String         PERSISTENT_NAME        = "AbstractRasterDataStore_Persistent";

    public static final String         PERSISTENT_DESCRIPTION = "AbstractRasterDataStore Persistent";

   // private Logger                     log                    = LoggerFactory.getLogger(AbstractRasterDataStore.class);

        protected DefaultRasterQuery       currentQuery           = null;

        protected BandListImpl             storeBandList          = null;

        protected RasterProvider           provider               = null;

        protected Metadata                 metadata               = null;

        /**

         * Lista de paletas asociadas a las bandas cargadas en el DataSource. Estas son calculadas

         * en las funciones que asignan las bandas a dibujar (addDrawableBands)

         */

        private ColorTable[]                           palette                = null;

        /**

         * Ancho y alto en pixeles del ?ltimo buffer asignado

         */

        protected double                                nWidth                 = 0;

        protected double                                nHeight                = 0;

        private Buffer                     lastBuffer             = null;

        private DataManager                dataManager            = null;

        protected DataStoreParameters      parameters             = null;

        private DelegatedDynObject         dynobj                 = null;

        private DelegateWeakReferencingObservable 

                                           delegateObservable     = new DelegateWeakReferencingObservable(this);

        private Render                     render                 = null;

        protected ICoordTrans              coordTrans             = null;

        protected RasterDataServerExplorer explorer               = null;

        public BandList getDefaultBandList() {

                if(storeBandList == null) {

                        initializeBandList();

                }

                return storeBandList;

        }

        public void initializeBandList() {

                if(provider != null) {

                        storeBandList = new BandListImpl();

                        storeBandList.clear();

                        for(int i = 0; i < provider.getBandCount(); i++) {

                                try {

                                        int dataType = provider.getDataType()[i];

                                        DatasetBand band = new DatasetBandImpl(provider.getURIByBand(i), 

                                                        provider.getBandPositionByProvider(i), 

                                                        dataType, 

                                                        provider.getBandCount());

                                        storeBandList.addBand(band, i);

                                } catch(BandNotFoundInListException ex) {

                                        //No a?adimos la banda

                                }

                        }

                        int[] drawableBands = new int[storeBandList.getBandCount()];

                        for (int i = 0; i < storeBandList.getBandCount(); i++) {

                                drawableBands[i] = i;

                        }

                        storeBandList.setDrawableBands(drawableBands);

                }

        }

        public Buffer query(RasterQuery query) throws ProcessInterruptedException, QueryException {

                Object[] obj = queryArray(query);

                if(obj != null && obj.length > 0 && obj[0] instanceof Buffer)

                        return ((Buffer)obj[0]);

                return null;

        }

        /**

         * <UL>Tasks to do in the <code>Datastore</code>

         * <LI>Check parameters and adjust them to not exceed the window size</LI>

         * <LI>Build the band list to draw</LI>

         * <LI>Create the buffers (RO or RW) and set them in the <code>RasterQuery</code> object</LI>

         * <LI>Calculate steps when supersampling is applied</LI>

         * </UL>

         */

        public Object[] queryArray(RasterQuery query)

                        throws ProcessInterruptedException, QueryException {

                Object[] result = null;

                currentQuery = (DefaultRasterQuery)query;

                DefaultRasterQuery q = currentQuery;

                if(isTiled() || provider instanceof RemoteRasterProvider)

                        q.dontBuildBuffer();

                Buffer buf = null;

                if(q.requestHasShift()) {

                        //TODO: Sin probar

                        FramedBufferResampling framedBufferResampling = new FramedBufferResampling(q, this);

                        buf = framedBufferResampling.query(provider);                        

                } else {

                        q.calculateParameters(this);

                        try {

                                if(q.isReadOnly() && !isTiled())

                                        buf = q.getBufferForProviders();

                                else

                                        buf = ((AbstractRasterProvider)provider).getDataSet(q);

                        } catch (RasterDriverException e) {

                                throw new QueryException("Error getting data", e);

                        }

                        if(q.isSupersamplingOptionActive() && q.isSupersamplingTheRequest()) {

                                buf = buf.getAdjustedWindow(q.getBufWidth(), q.getBufHeight(), Buffer.INTERPOLATION_NearestNeighbour);

                        }

                }

                if(buf != null)

                        buf.setDataExtent(q.getAdjustedRequestBoundingBox().toRectangle2D());

                result = new Object[]{buf};

                if(q.isStoredLastBuffer())

                        lastBuffer = buf;

                else

                        lastBuffer = null;

                q.storeLastBuffer(false);

                if(result != null && result.length > 0 && result[0] instanceof Buffer) {

                        ((Buffer)result[0]).setStore(this);

                        if(getNoDataValue() != null && getNoDataValue().isDefined())

                                ((Buffer)result[0]).setNoDataValue(getNoDataValue());

                        return result;

                }

                return null;

        }

        public Extent adjustToExtent(Extent e) {

                Extent currentExtent = this.getExtent();

                double minx = e.getMin().getX() < currentExtent.getMin().getX() ? currentExtent.getMin().getX() : e.getMin().getX();

                double maxx = e.getMax().getX() > currentExtent.getMax().getX() ? currentExtent.getMax().getX() : e.getMax().getX();

                double miny = e.getMin().getY() < currentExtent.getMin().getY() ? currentExtent.getMin().getY() : e.getMin().getY();

                double maxy = e.getMax().getY() > currentExtent.getMax().getY() ? currentExtent.getMax().getY() : e.getMax().getY();

                return new ExtentImpl(minx, maxy, maxx, miny);

        }

        public String getFullName() {

                return getName();

        }

        public Buffer getLastBuffer() {

                return lastBuffer;

        }

        public TimeSeries getTimeSerials() throws RmfSerializerException {

                if(getProvider() instanceof RasterProvider)

                        return ((RasterProvider)getProvider()).getTimeSerials();

                return null;

        }

        public void setTimeSerials(TimeSeries serialInfo) throws RmfSerializerException {

                if(getProvider() instanceof RasterProvider)

                        ((RasterProvider)getProvider()).setTimeSerials(serialInfo);                        

        }

        public abstract void saveColorTableToRmf(ColorTable table) throws RmfSerializerException;

        public abstract void saveGeoPointListToRmf(GeoPointList pointList) throws RmfSerializerException;

        public abstract void saveROIFileListToRmf(List<File> fileList) throws RmfSerializerException;

        /**

         * Saves information about serials

         * @param object to save

         * @throws RmfSerializerException

         */

        public abstract void saveSerialInfoToRmf(TimeSeries serialInfo) throws RmfSerializerException;

        /**

         * Loads information about serials

         * @param object to load

         * @throws RmfSerializerException

         */

        public abstract boolean loadSerialInfoFromRmf(TimeSeries serialInfo);

        public Vectorization createVectorizeObject() throws QueryException, ProcessInterruptedException {

                return new PotraceVectorization((RasterDataStore)this);

        }

        public Render getRender() {

                if(render == null)

                        render = new DefaultRender(this);

                return render;

        }

        public void setRender(Render render) {

                this.render = render;

        }

        public boolean isFileSupported(String fName) {

                return RasterLocator.getManager().getProviderServices().isExtensionSupported(fName);

        }

        /**

         * Registers metadata definition

         * @throws MetadataException

         */

        public static void registerMetadataDefinition() throws MetadataException {

                MetadataManager manager = MetadataLocator.getMetadataManager();

                if(manager == null)

                        return;

                if( manager.getDefinition(METADATA_DEFINITION_NAME) == null  ) {

                        DynStruct defnition = manager.addDefinition(

                                        METADATA_DEFINITION_NAME,

                                        METADATA_DEFINITION_NAME 

                        );

                        defnition.extend(

                                        MetadataManager.METADATA_NAMESPACE, 

                                        DataStore.METADATA_DEFINITION_NAME

                        );

                }

        }

        public int getSourceType() {

                return ((RasterProvider)getProvider()).getSourceType();

        }

    //****************************************************

        //****Implementing DataStoreImplementation methods****

        //****************************************************

        public void intializePhase1(DataManager dataManager,

                        DataStoreParameters parameters) throws InitializeException {

                DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

                this.dynobj = (DelegatedDynObject) dynManager

                                .createDynObject( 

                                                MetadataLocator.getMetadataManager().getDefinition(DataStore.SPATIAL_METADATA_DEFINITION_NAME)

                                );

                this.dataManager = dataManager;

                this.parameters = parameters;

        }

        public void intializePhase2(DataStoreProvider provider)

                        throws InitializeException {

                setProvider((RasterProvider)provider);

        }

        public DataManager getManager() {

                return this.dataManager;

        }        

        //****************************************************

        //*********Implementing DataStore methods*************

        //****************************************************

        public String getProviderName() {

                return getProvider().getFullName();

        }

        public void refresh() throws DataException {

                return;

        }

        public DataSet getDataSet() throws DataException {

                RasterQuery query = DefaultRasterManager.getInstance().createQuery();

                query.setSupersamplingOption(false);

                query.setAreaOfInterest();

                int[] bands = new int[getBandCount()];

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

                        bands[i] = i;

                }

                query.setDrawableBands(bands);

                return getDataSet(query);

        }

        public DataSet getDataSet(DataQuery dataQuery) throws DataException {

                if(dataQuery instanceof RasterQuery) {

                        Object[] obj = null;

                        try {

                                obj = queryArray((RasterQuery)dataQuery);

                        } catch (ProcessInterruptedException e) {

                                throw new RasterDriverException("", e);

                        } catch (QueryException e) {

                                throw new RasterDriverException(e.getMessage(), e);

                        }

                        if(obj != null && obj.length > 0 && obj[0] instanceof Buffer)

                                return (Buffer)obj[0];

                }

                return null;

        }

        public void accept(Visitor visitor, DataQuery dataQuery)

                        throws BaseException {

        }

        public void getDataSet(org.gvsig.tools.observer.Observer observer) throws DataException {

                RasterQuery query = DefaultRasterManager.getInstance().createQuery();

                query.setSupersamplingOption(false);

                query.setAreaOfInterest();

                int[] bands = new int[getBandCount()];

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

                        bands[i] = i;

                }

                query.setDrawableBands(bands);

                getDataSet(query, observer);

        }

        public void getDataSet(DataQuery dataQuery, org.gvsig.tools.observer.Observer observer) throws DataException {

                if(dataQuery instanceof RasterQuery) {

                        Object[] obj = null;

                        try {

                                obj = queryArray((RasterQuery)dataQuery);

                        } catch (ProcessInterruptedException e) {

                        } catch (QueryException e) {

                                throw new RasterDriverException(e.getMessage(), e);

                        }

                        if(obj != null && obj.length > 0 && obj[0] instanceof Buffer)

                                observer.update(this, obj[0]);

                }

        }

        public DataSet getSelection() throws DataException {

                return null;

        }

        public void setSelection(DataSet selection) throws DataException {

        }

        public DataSet createSelection() throws DataException {

                return null;

        }

        public Iterator<?> getChildren() {

                return null;

        }

        public DataServerExplorer getExplorer() throws DataException, ValidateDataParametersException {

                return explorer;

        }

        /**

     * Sets the explorer

     * @param explorer

     */

    public void setExplorer(RasterDataServerExplorer explorer) {

            this.explorer = explorer;

    }

        public DataQuery createQuery() {

                return new DefaultRasterQuery();

        }

        //****************************************************

        //*********Implementing Metadata methods*************

        //****************************************************

    public Object getMetadataID() {

            if(parameters != null && parameters instanceof RasterFileStoreParameters)

                    return ((RasterFileStoreParameters)parameters).getFile();

            if(parameters != null && parameters instanceof RasterDataParameters)

                    return ((RasterDataParameters)parameters).getURI();

            return null;

    }

        public Set<?> getMetadataChildren() {

            return null;

    }

    //****************************************************

        //*********Implementing Disposable methods************

        //****************************************************

    public void doDispose() {

    }

    //****************************************************

        //*********Implementing Visitable methods*************

        //****************************************************

    public void accept(Visitor visitor) throws BaseException {

    }

    //****************************************************

        //****Implementing ComplexObservable methods**********

        //****************************************************

    public void disableNotifications() {

        }

    public void enableNotifications() {

        }

    public void beginComplexNotification() {

        }

    public void endComplexNotification() {

        }

    //****************************************************

        //********Implementing Observable methods*************

        //****************************************************

        public void addObserver(org.gvsig.tools.observer.Observer o) {

        }

        public void deleteObserver(org.gvsig.tools.observer.Observer o) {

        }

        public void deleteObservers() {

        }

    //****************************************************

        //********Implementing DynObject methods*************

        //****************************************************

        public DynClass getDynClass() {

                return this.dynobj.getDynClass();

        }

        public void implement(DynClass dynClass) {

                this.dynobj.implement(dynClass);

    }

        public void delegate(DynObject dynObject) {

                this.dynobj.delegate(dynObject);

    }

        public Object getDynValue(String name)  throws DynFieldNotFoundException {

                return this.dynobj.getDynValue(name);

        }

        public void setDynValue(String name, Object value)  throws DynFieldNotFoundException {

                this.dynobj.setDynValue(name, value);

    }

        public boolean hasDynValue(String name) {

                return this.dynobj.hasDynValue(name);

        }

        public Object invokeDynMethod(String name, DynObject context) throws DynMethodException {

                return this.dynobj.invokeDynMethod(this, name, context);

        }

        public Object invokeDynMethod(int code, DynObject context) throws DynMethodException {

                return this.dynobj.invokeDynMethod(this, code, context);

        }

        public void clear() {

                if (dynobj != null) {

                        dynobj.clear();

                }

    }

        public DataStoreParameters getParameters() {

                return parameters;

        }

        //***********************************************************************

        //********Implementing CoverageStoreProviderServices methods*************

        //***********************************************************************

        public CoverageSelection createDefaultCoverageSelection()

        throws DataException {

                return null;

        }

        public CoverageStore getCoverageStore() {

                return this;

        }

        public abstract CoverageStoreProvider getProvider();

        public void notifyChange(String notification) {

                delegateObservable

                .notifyObservers(new DefaultCoverageStoreNotification(

                                this, notification));

        }

        public void notifyChange(String arg0, Resource arg1) {

                /*delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

                                this, FeatureStoreNotification.RESOURCE_CHANGED));*/

        }

        public void notifyChange(String notification, Command command) {

                delegateObservable

                .notifyObservers(new DefaultCoverageStoreNotification(

                                this, notification, command));

        }

        public DataStore getStore() {

                return this;

        }

        public void setCoordTrans(ICoordTrans t) {

                this.coordTrans = t;

        }

        public void close() {

                if(lastBuffer != null) {

                        lastBuffer.dispose();

                }

        }

        protected void finalize() throws Throwable {

                currentQuery           = null;

                if(palette != null) {

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

                                palette[i] = null;

                        }

                        palette = null;

                }

                lastBuffer             = null;

                dataManager            = null;

                parameters             = null;

                metadata               = null;

                delegateObservable     = null;

                render                 = null;

                super.finalize();

        }

}