Application: gvSIG desktop

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

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {Iver T.I.}   {Task}

 */

package org.gvsig.app.eventtheme.dal.feature;

import java.util.Arrays;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.feature.AbstractFeatureStoreTransform;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

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

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * This class implements a transformation for a events theme. The original 

 * {@link DataStore} have to have a couple of attributes, one with the X 

 * coordinate and the second one with the Y coordinate. The result of 

 * the transformation is a {@link DataStore} that has a new geometric 

 * attribute and its value is a point with the coordinates specified in 

 * the original {@link DataStore}. 

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class EventThemeTransform extends AbstractFeatureStoreTransform {

    public static final String PERSISTENCE_DEFINITION_NAME = "EventThemeTransform";

    private String xFieldName = null;

    private String yFieldName = null;

    private String geometryFieldName = null;

    private IProjection projection = null;

    private FeatureType originalFeatureType;

    private GeometryManager geometryManager = GeometryLocator.getGeometryManager();    

    private Envelope envelope;

    public EventThemeTransform() {

        super();

        geometryManager = GeometryLocator.getGeometryManager();

    }

    /**

     * This method initializes the transformation, sets the name of the parameters and 

     * sets the value of the {@link FeatureType} returned by the transformation. 

     * @param store

     * The original store. 

     * @param geometryFieldName

     * The field that contains the geometric attribute.

     * @param xFieldName

     * The field that contains the X coordinate.

     * @param yFieldName

     * The field that contains the Y coordinate.

     * @throws DataException

     */

    public void initialize(FeatureStore store, String geometryFieldName, String xFieldName, String yFieldName,

        IProjection projection) throws DataException{

        setFeatureStore(store);

        this.xFieldName = xFieldName;

        this.yFieldName = yFieldName;

        this.projection = projection;

        if ((geometryFieldName == null) || (geometryFieldName.equals(""))){

            this.geometryFieldName = "the_geom";

        }else{

            this.geometryFieldName = geometryFieldName;

        }

        this.originalFeatureType = this.getFeatureStore()

        .getDefaultFeatureType();

        EditableFeatureType type = originalFeatureType.getEditable();

        if (type.get(this.geometryFieldName) == null){

            EditableFeatureAttributeDescriptor attributeDescriptor = type.add(this.geometryFieldName,  DataTypes.GEOMETRY);

            try {

                attributeDescriptor.setGeometryType(geometryManager.getGeometryType(TYPES.POINT, SUBTYPES.GEOM2D));

            } catch (GeometryTypeNotSupportedException e) {

                throw new InitializeException(e);

            } catch (GeometryTypeNotValidException e) {

                throw new InitializeException(e);

            }           

            attributeDescriptor.setSRS(projection);

        }

        try {

            envelope = geometryManager.createEnvelope(SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e) {

            throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);

        }

        type.setDefaultGeometryAttributeName(this.geometryFieldName);

        FeatureType[] types = new FeatureType[] { type.getNotEditableCopy() };

        setFeatureTypes(Arrays.asList(types), types[0]);

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#applyTransform(org.gvsig.fmap.dal.feature.Feature, org.gvsig.fmap.dal.feature.EditableFeature)

     */

    public void applyTransform(Feature source, EditableFeature target)

    throws DataException {

        this.copySourceToTarget(source, target);

        try {                        

            Point point = geometryManager.createPoint(

                new Double(source.get(xFieldName).toString()),

                new Double(source.get(yFieldName).toString()),

                SUBTYPES.GEOM2D);

            target.set(geometryFieldName, point);

            target.setDefaultGeometry(point);        

            envelope.add(point.getEnvelope());

        } catch (CreateGeometryException e) {

            throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(TYPES.POINT, SUBTYPES.GEOM2D, e);

        }                

    }

    /**

     * @param source

     * @param target

     */

    private void copySourceToTarget(Feature source, EditableFeature target) {

        FeatureAttributeDescriptor attr, attrTrg;

        FeatureType ftSrc = source.getType();

        FeatureType ftTrg = target.getType();

        for (int i = 0; i < source.getType().size(); i++) {

            attr = ftSrc.getAttributeDescriptor(i);

            if (ftTrg.getIndex(attr.getName()) > -1) {

                try {

                    target.set(attr.getName(), source.get(i));

                } catch (IllegalArgumentException e) {

                    attrTrg = ftTrg.getAttributeDescriptor(attr.getName());

                    target.set(attrTrg.getIndex(), attrTrg.getDefaultValue());

                }

            }

        }

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#getSourceFeatureTypeFrom(org.gvsig.fmap.dal.feature.FeatureType)

     */

    public FeatureType getSourceFeatureTypeFrom(FeatureType targetFeatureType) {

        return this.originalFeatureType;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#isTransformsOriginalValues()

     */

    public boolean isTransformsOriginalValues() {

        return true;

    }

    public static void registerPersistent() {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        if( persistenceManager.getDefinition(AbstractFeatureStoreTransform.class) == null ) {

            AbstractFeatureStoreTransform.registerPersistent();

        }

        DynStruct definition = persistenceManager.getDefinition(PERSISTENCE_DEFINITION_NAME);

        if (definition == null){           

            definition = persistenceManager.addDefinition(

                EventThemeTransform.class,

                PERSISTENCE_DEFINITION_NAME,

                "EventThemeTransform Persistence definition",

                null, 

                null

            );

            definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,

                ABSTRACT_FEATURESTORE_DYNCLASS_NAME);

            definition.addDynFieldString("geometryFieldName").setMandatory(true);

            definition.addDynFieldString("xFieldName").setMandatory(true);

            definition.addDynFieldString("yFieldName").setMandatory(true);

            definition.addDynFieldObject("projection").setType(DataTypes.CRS);

        }

    }

    /* (non-Javadoc)

     * @see org.gvsig.tools.persistence.Persistent#saveToState(org.gvsig.tools.persistence.PersistentState)

     */

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("geometryFieldName", this.geometryFieldName);

        state.set("xFieldName", this.xFieldName);

        state.set("yFieldName", this.yFieldName);

        state.set("projection", this.projection);                

    }

    /* (non-Javadoc)

     * @see org.gvsig.tools.persistence.Persistent#loadFromState(org.gvsig.tools.persistence.PersistentState)

     */

    public void loadFromState(PersistentState state)

    throws PersistenceException {

        super.loadFromState(state);                

        String geometryFieldName = state.getString("geometryFieldName");

        String xFieldName = state.getString("xFieldName");

        String yFieldName = state.getString("yFieldName");

        IProjection projection =  (IProjection)state.get("projection");        

        try {

            initialize(getFeatureStore(), geometryFieldName, xFieldName, yFieldName, projection);

        } catch (DataException e) {

            throw new PersistenceException("Impossible to create the transform", e);

        }

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if (DataStore.METADATA_CRS.equals(name)){

            return projection;

        }else if(DataStore.METADATA_ENVELOPE.equals(name)){

            return envelope;

        }

        return null;

    }

    public boolean hasDynValue(String name) {

        return ((DataStore.METADATA_CRS.equals(name)) || 

            (DataStore.METADATA_ENVELOPE.equals(name)));

    }    

}