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

import java.net.URISyntaxException;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Base class for all kind of parameters in raster

 * TODO: Now it only accepts files. Maybe in the future other kind of sources could be accepted like remote services (URL)

 * 

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

 */

public abstract class AbstractRasterDataParameters extends AbstractDataParameters implements

                RasterDataParameters {

        public static final String     PERSISTENT_NAME        = "AbstractRasterDataParameters_Persistent";

    public static final String     PERSISTENT_DESCRIPTION = "AbstractRasterDataParameters Persistent";

        protected static final String  FIELD_URI              = "uri";

        private static final String    FIELD_CRS              = "CRS";

        private static final String    FIELD_FRAME            = "frame";

        private static final String    FIELD_ALPHABAND        = "alphaband";

        private static final String    FIELD_VISIBLE          = "visible";

        private static final String    FIELD_REPROJ_OPTION    = "selected_option";

        public static DynClass registerDynClass(String dynClassName) {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynField field;

                if(dynman == null)

                        return null;

                DynClass dynClass = dynman.add(dynClassName);

                field = dynClass.addDynFieldString(FIELD_URI);

                field.setDescription("Uniform Resource Identifier (File name or URL)");

                field.setClassOfValue(String.class);

                field.setMandatory(false);

                field = dynClass.addDynFieldObject(FIELD_CRS);

                field.setDescription("CRS");

                field.setClassOfValue(Object.class);

                field.setMandatory(false);

                field = dynClass.addDynFieldInt(FIELD_FRAME);

                field.setDescription("frame");

                field.setClassOfValue(Integer.class);

                field.setMandatory(false);

                field = dynClass.addDynFieldInt(FIELD_ALPHABAND);

                field.setDescription("alphaband");

                field.setClassOfValue(Integer.class);

                field.setMandatory(false);

                field = dynClass.addDynFieldObject(FIELD_VISIBLE);

        field.setDescription("If the boolean in i position is true, that means that the i provider is visible");

        field.setMandatory(false);

        field.setClassOfValue(Object.class);

                field = dynClass.addDynFieldInt(FIELD_REPROJ_OPTION);

                field.setDescription("Reprojection option");

                field.setClassOfValue(Integer.class);

                field.setDefaultFieldValue(new Integer(0));

                field.setMandatory(false);

                return dynClass;

        }

        public AbstractRasterDataParameters() {

                super();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#setReprojectionOption(int)

         */

        public void setReprojectionOption(int option) {

                this.setDynValue(FIELD_REPROJ_OPTION, option);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#getReprojectionOption()

         */

        public int getReprojectionOption() {

                Integer b = (Integer)getDynValue(FIELD_REPROJ_OPTION);

                if(b != null)

                        return ((Integer)b).intValue();

                return 0;

        }

        public boolean isValid() {

                return (this.getURI() != null);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.RasterStoreParameters#getURI()

         */

        public String getURI() {

                return (String) this.getDynValue(FIELD_URI);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.RasterStoreParameters#setURI(java.lang.String)

         */

        public void setURI(String uri) {

                this.setDynValue(FIELD_URI, uri);

        }

        public String getSRSID() {

                IProjection srs = (IProjection) getDynValue(FIELD_CRS);

                if (srs == null) {

                        return null;

                }

                return srs.getAbrev();

        }

        public void setSRSID(String srsid) {

                if (srsid == null) {

                        setDynValue(FIELD_CRS, null);

                } else {

                        setDynValue(FIELD_CRS, CRSFactory.getCRS(srsid));

                }

        }

        public void setSRS(IProjection srs) {

                setDynValue(FIELD_CRS, srs);

        }

        public IProjection getSRS() {

                if (this.getSRSID() == null) {

                        return null;

                }

                return (IProjection) getDynValue(FIELD_CRS);

        }

        /**

         * Sets the number of alpha band

         * @param alphaBand

         */

        public void setAlphaBand(int alphaBand) {

                this.setDynValue(FIELD_ALPHABAND, new Integer(alphaBand));

        }

        /**

         * Sets the frame width

         * @param frame

         */

        public void setFrame(int frame) {

                this.setDynValue(FIELD_FRAME, new Integer(frame));

        }

        /**

         * Gets the number of alpha band

         * @param alphaBand

         */

        public int getAlphaBand() {

                Integer b = (Integer)getDynValue(FIELD_ALPHABAND);

                if(b != null)

                        return ((Integer)b).intValue();

                return 0;

        }

        /**

         * Gets the frame width

         * @param frame

         */

        public int getFrame() {

                Integer b = (Integer)getDynValue(FIELD_FRAME);

                if(b != null)

                        return ((Integer)b).intValue();

                return 0;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#isVisible()

         */

        public boolean isVisible() {

                Boolean b = (Boolean)getDynValue(FIELD_VISIBLE);

                if(b != null)

                        return ((Boolean)b).booleanValue();

                return true;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters#setVisible(boolean)

         */

        public void setVisible(boolean visible) {

                this.setDynValue(FIELD_VISIBLE, new Boolean(visible));

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.AbstractDataParameters#loadFromState(org.gvsig.tools.persistence.PersistentState)

         */

        public void loadFromState(PersistentState state) throws PersistenceException {

                String uriString = null;

                try {

                        URI uri = state.getURI(FIELD_URI);

                        if(uri != null) {

                                uriString = uri.toString();

                                if(uri.getScheme() == null || "file".equalsIgnoreCase(uri.getScheme()))

                                        uriString = uri.getPath();

                        }

                } catch(ClassCastException e) {

                        uriString = state.getString(FIELD_URI);

                }

                setURI(uriString);

                setSRS((IProjection)state.get(FIELD_CRS));

                setAlphaBand(state.getInt(FIELD_ALPHABAND));

                setFrame(state.getInt(FIELD_FRAME));

                setVisible(state.getBoolean(FIELD_VISIBLE));

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.AbstractDataParameters#saveToState(org.gvsig.tools.persistence.PersistentState)

         */

        public void saveToState(PersistentState state) throws PersistenceException {

                try {

                        String uri = getURI();

                        if(uri != null)

                                state.set(FIELD_URI, new URI(uri));

                } catch (URISyntaxException e) {

                        throw new PersistenceException(e);

                }

                state.set(FIELD_CRS, getSRS());

                state.set(FIELD_ALPHABAND, getAlphaBand());

                state.set(FIELD_FRAME, getFrame());

                state.set(FIELD_VISIBLE, isVisible());

        }        

        public static void registerPersistence(DynStruct definition) {

                definition.addDynFieldURI(FIELD_URI).setMandatory(false);

                definition.addDynFieldObject(FIELD_CRS).setClassOfValue(IProjection.class).setMandatory(false);

                definition.addDynFieldInt(FIELD_ALPHABAND).setMandatory(false);

                definition.addDynFieldInt(FIELD_FRAME).setMandatory(false);

                definition.addDynFieldBoolean(FIELD_VISIBLE).setMandatory(false);

        }

}