Application: gvSIG desktop » gvSIG Linear Reference System

import java.io.File;

import java.util.Map.Entry;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

import org.gvsig.fmap.dal.store.shp.SHPNewStoreParameters;

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

import org.gvsig.tools.dataTypes.DataType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

        try {

            final String routeFieldName=idRouteField.getName();

            final String fromFieldName;

            final DataType fromDataType;

            final DataType toDataType;

            if (fromMeasureField!=null){

                fromFieldName=fromMeasureField.getName();

                fromDataType=fromMeasureField.getDataType();

            }else{

                fromFieldName=null;

                fromDataType=null;

            }

            final String toFieldName;

            if (toMeasureField!=null){

                toFieldName=toMeasureField.getName();

                toDataType=toMeasureField.getDataType();

            }else{

                toFieldName=null;

                toDataType=null;

            }

            DataStore newDataStore=createNewDataStore(newFeatureStoreParameters,idRouteField);

            FeatureSet sourceFeatures;

            if (sourceFeatureStore.getFeatureSelection().getSize()>0){

                sourceFeatures=sourceFeatureStore.getFeatureSelection();

            }else{

                sourceFeatures=sourceFeatureStore.getFeatureSet();

            }

            final Map<String,List<MStructure>> featuresMap=new HashMap<String, List<MStructure>>();

            sourceFeatures.accept(new Visitor() {

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    Feature feature=(Feature)obj;

                    String routeName=(String)feature.get(routeFieldName);

                    Geometry originalGeometry=feature.getDefaultGeometry();

                    Object objFrom=null;

                    Object objTo=null;

                    if (fromFieldName!=null){

                        objFrom=feature.get(fromFieldName);

                    }

                    if (toFieldName!=null){

                        objTo=feature.get(toFieldName);

                    }

                    if (!featuresMap.containsKey(routeName)){

                        featuresMap.put(routeName, new ArrayList<MStructure>());

                    }

                    List<MStructure> mList=featuresMap.get(routeName);

                    MStructure mStructure=new MStructure();

                    mStructure.geometry=originalGeometry;

                    mStructure.fromField=getDouble(objFrom,fromDataType);

                    mStructure.toField=getDouble(objTo,toDataType);

                    mList.add(mStructure);

                    featuresMap.put(routeName, mList);

            });

            taskStatus.setRangeOfValues(0, featuresMap.size()-1);

            int taskCount=0;

            FeatureStore featureStore=(FeatureStore)newDataStore;

            featureStore.edit(FeatureStore.MODE_FULLEDIT);

            for(Entry<String, List<MStructure>> entry : featuresMap.entrySet()) {

                String routeName = entry.getKey();

                List<MStructure> mList = entry.getValue();

                EditableFeature newFeature = featureStore.createNewFeature(true);

                newFeature.set(routeFieldName, routeName);

                Geometry route = createGeometryRoute(mList);

                newFeature.setDefaultGeometry(route);

                featureStore.update(newFeature);

                taskStatus.setCurValue(taskCount);

                taskCount++;

            featureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

            throw new LrsCreateRouteException("Error creating routes", e1);

    private DataStore createNewDataStore(NewFeatureStoreParameters newFeatureStoreParameters,FeatureAttributeDescriptor idRouteField)

        throws LrsCreateRouteException{

        try {

            SHPNewStoreParameters shapeStoreParams = (SHPNewStoreParameters)newFeatureStoreParameters;

            File file=shapeStoreParams.getFile();

            String filePath=file.getPath().substring(0, file.getPath().lastIndexOf(File.separator));

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorerParameters serverParams =

                dataManager.createServerExplorerParameters("FilesystemExplorer");

            serverParams.setDynValue("initialpath", filePath);

            DataServerExplorer serverExplorer =

                dataManager.openServerExplorer(serverParams.getExplorerName(), serverParams);

            EditableFeatureType featureType = (EditableFeatureType)shapeStoreParams.getDefaultFeatureType();

            featureType.add(idRouteField.getName(), idRouteField.getType(), idRouteField.getSize());

            EditableFeatureAttributeDescriptor geometryField = featureType.add("Geometry", DataTypes.GEOMETRY);

            GeometryType geometryType = GeometryLocator.getGeometryManager().getGeometryType(Geometry.TYPES.MULTICURVE, Geometry.SUBTYPES.GEOM2D);

            geometryField.setGeometryType(geometryType);

            featureType.setDefaultGeometryAttributeName("Geometry");

            shapeStoreParams.setDefaultFeatureType(featureType);

            serverExplorer.add("Shape", shapeStoreParams, true);

            DataStore store = dataManager.createStore(shapeStoreParams);

            return store;

        } catch (Exception e) {

            throw new LrsCreateRouteException("Error creating new dataStore", e);

        }

    }

    private Geometry createGeometryRoute(List<MStructure> mList) throws CreateGeometryException{

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

        //TODO Must be changed to Multiline and GEOM2DM

        MultiLine routeGeometry= (MultiLine)geomanager.create(Geometry.TYPES.MULTICURVE, Geometry.SUBTYPES.GEOM2D);

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            if (geometry instanceof Line){

                routeGeometry.addPrimitive((Line)geometry);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine =(MultiLine) geometry;

                for (int i=0;i<multiLine.getPrimitivesNumber();i++){

                    routeGeometry.addPrimitive(multiLine.getPrimitiveAt(i));

                }

            }

        }

        return routeGeometry;

    }

    private Double getDouble(Object obj,DataType dataType){

        Double result=Double.NaN;

        if (dataType.equals(DataTypes.DOUBLE)){

            result=(Double)obj;

        }else {

            result=Double.valueOf(String.valueOf(obj));

        }

        return result;

    }

class MStructure{

    Geometry geometry;

    Double fromField;

    Double toField;

}