Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3

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

 */

/*

 * AUTHORS (In addition to CIT):

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

 */

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

import java.util.Arrays;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

    private static Logger LOGGER = LoggerFactory.getLogger(EventThemeTransform.class);

    public static final String PERSISTENCE_DEFINITION_NAME = "EventThemeTransform";

    /**

     * Max number of features used for initial estimation of extent. Many other

     * features will be ignored simply with "iter.next()"

     */

    public static int MAX_INI_FEATURES = 200;

    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.

     * @param projection

     * @throws DataException

     */

    public void setValues(

        FeatureStore store,

        String geometryFieldName,

        String xFieldName,

        String yFieldName,

        IProjection projection) throws DataException {

        setFeatureStore(store);

        this.xFieldName = xFieldName;

        this.yFieldName = yFieldName;

        this.projection = projection;

        if( StringUtils.isEmpty(geometryFieldName) ) {

            this.geometryFieldName = "the_geom";

        } else {

            this.geometryFieldName = geometryFieldName;

        }

    }

    @Override

    public void setUp() throws Exception {

        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 | GeometryTypeNotValidException e) {

                throw new InitializeException(e);

            }

            attributeDescriptor.setSRS(projection);

            attributeDescriptor.setFeatureAttributeEmulator(new FeatureAttributeEmulator() {

                @Override

                public Object get(Feature feature) {

                    Geometry point = null;

                    Object xval = feature.get(xFieldName);

                    Object yval = feature.get(yFieldName);

                    if( xval == null || yval == null ) {

                        LOGGER.info("Found row with null coordinates in event theme (created null geometry)");

                        return null;

                    } else {

                        try {

                            point = geometryManager.createPoint(

                                    new Double(xval.toString()),

                                    new Double(yval.toString()),

                                    SUBTYPES.GEOM2D);

                        } catch (CreateGeometryException ex) {

                        }

                        return point;

                    }

                }

                @Override

                public void set(EditableFeature feature, Object value) {

                    throw new UnsupportedOperationException("Not supported yet.");

                }

                @Override

                public boolean allowSetting() {

                    return false;

                }

                @Override

                public String[] getRequiredFieldNames() {

                    return new String[] { xFieldName, yFieldName };

                }

                @Override

                public JsonObject toJson() {

                    return null;

                }

                @Override

                public JsonObjectBuilder toJsonBuilder() {

                    return null;

                }

                @Override

                public void fromJson(JsonObject json) {

                }

            });

        }

        try {

            /*

             * creates and updates envelope with all features

             */

            initEnvelope(this.getFeatureStore(), MAX_INI_FEATURES);

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

    }

    /**

     * creates and updates envelope with all features

     *

     */

    private void initEnvelope(FeatureStore theStore, int max_feats) throws CreateEnvelopeException {

        envelope = geometryManager.createEnvelope(SUBTYPES.GEOM2D);

        FeatureSet fset = null;

        DisposableIterator diter = null;

        Feature feat = null;

        try {

            fset = theStore.getFeatureSet();

            diter = fset.fastIterator();

            // int count = 0;

            int countused = 0;

            int nextwait = 1;

            int index = 0;

            while( diter.hasNext() && (countused < max_feats) ) {

                feat = (Feature) diter.next();

                /*

                 * This loop will use about 70 features from the first

                 * 3000 features, more and more separated each time.

                 * Something like:

                 * 

                 * 1st, 2nd ,3rd, 5th, 8th, 15, 25, 40, 100, 300...

                 * 

                 * Other features are ignored with diter.next().

                 * That causes an acceptable behavior even if the store

                 * is very large.

                 * 

                 * Afterwards, the extent is updated while drawing,

                 * so it's not very important.

                 */

                index++;

                if( index == nextwait ) {

                    index = 0;

                    /*

                         * This causes that the first 5 features

                         * will always be used.

                     */

                    if( countused > 5 ) {

                        nextwait++;

                    }

                    this.updateEnvelope(feat);

                    countused++;

                }

                // count++;

            }

            diter.dispose();

        } catch (Exception dex) {

            throw new CreateEnvelopeException(SUBTYPES.GEOM2D, dex);

        }

    }

    public void setEnvelope(Envelope env) {

        this.envelope = env;

    }

    @Override

    public void applyTransform(Feature source, EditableFeature target)

        throws DataException {        

        target.copyFrom(source);

    }

    /**

     * Used internally to initialize envelope

     *

     */

    private void updateEnvelope(Feature feat) throws CreateGeometryException {

        Point point = geometryManager.createPoint(

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

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

            SUBTYPES.GEOM2D);

        envelope.add(point.getEnvelope());

    }

    @Override

    public FeatureType getSourceFeatureTypeFrom(FeatureType targetFeatureType) {

        return this.originalFeatureType;

    }

    @Override

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

        }

    }

    @Override

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

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        geometryFieldName = state.getString("geometryFieldName");

        xFieldName = state.getString("xFieldName");

        yFieldName = state.getString("yFieldName");

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

    }

    @Override

    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;

    }

    @Override

    public boolean hasDynValue(String name) {

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

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

    }

}