Application: gvSIG desktop

package org.gvsig.export.impl.service;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.spi.ExportGeometryHelper;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExportGeometryHelper implements ExportGeometryHelper {

        private final int targetGeometryIndex;

        private final int sourceGeometryIndex;

        private final ICoordTrans coord_trans;

        private boolean isExtraColumn;

        private String sourceGeometryName;

        private final ExportServiceManager serviceManager;

        private final ExportParametersGeometry parameters;

        private String lastErrorMessage;

        public DefaultExportGeometryHelper(

            ExportParametersGeometry parameters,

            FeatureType theTargetFeatureType,

            FeatureType theSourceFeatureType

        ) {

            this.serviceManager = ExportLocator.getServiceManager();

            this.parameters = parameters;

            FeatureAttributeDescriptor sourceGeomAtt = theSourceFeatureType.getDefaultGeometryAttribute();

            FeatureAttributeDescriptor targetGeomAtt;

            this.isExtraColumn = false;

            String sourceGeometryFieldName = this.parameters.getSourceGeometryFieldName();

            if( !StringUtils.isEmpty(sourceGeometryFieldName) ) {

                sourceGeomAtt = theSourceFeatureType.getAttributeDescriptor(sourceGeometryFieldName);

                if (sourceGeomAtt == null) {

                    sourceGeomAtt = theSourceFeatureType.getExtraColumns().get(sourceGeometryFieldName);

                    this.isExtraColumn = (sourceGeomAtt!=null);

                }

            }

            if (sourceGeomAtt == null) {

                // Si el origen no tiene geometria, no haremos nada con las

                // geometrias.

                this.targetGeometryIndex = -1;

                this.sourceGeometryIndex = -1;

                this.coord_trans = null;

                return;

            }

            switch( this.getGeometryColumnCount(theTargetFeatureType) ) {

                case 0:

                    // Si el destino no tiene campo geometry no haremos nada con 

                    // las geometrias.

                    this.targetGeometryIndex = -1;

                    this.sourceGeometryIndex = -1;

                    this.coord_trans = null;

                    return;

                case 1:

                    // Si solo hay una columna de geometria asignaremos las geometrias

                    // independientemente de como se llamen los campos.

                    targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute();

                    break;

                default:

                    // Si hay mas de una geometria en el target y hay un campo de tipo

                    // geometria que coincida en nombre con el del source, usamos ese.

                    targetGeomAtt = theTargetFeatureType.getAttributeDescriptor(sourceGeomAtt.getName());

                    if( targetGeomAtt == null || targetGeomAtt.getType()!=DataTypes.GEOMETRY ) {

                        // Si no coinciden por nombre y tipo, pillaremos el primer campo

                        // geometry por defecto del target.

                        targetGeomAtt = theTargetFeatureType.getDefaultGeometryAttribute();

                        if( targetGeomAtt==null ) {

                            targetGeomAtt = this.getFirstGeometryColumn(theTargetFeatureType);

                            if( targetGeomAtt == null ) {

                                this.targetGeometryIndex = -1;

                                this.sourceGeometryIndex = -1;

                                this.coord_trans = null;

                                return;

                            }

                        }

                    }

            }

            IProjection targetProjection = this.parameters.getTargetProjection();

            IProjection sourceProjection = sourceGeomAtt.getSRS();

            if( targetProjection == null ) {

                targetProjection = sourceProjection;

            }

            // this comparison is perhaps too preventive

            // we could  have two instances of same projection

            // so we would do more computations than needed

            if (sourceProjection != null && targetProjection != null && sourceProjection != targetProjection) {

                this.coord_trans = sourceProjection.getCT(targetProjection);

            } else {

                this.coord_trans = null;

            }

            if( this.isExtraColumn ) {

                this.sourceGeometryIndex = theSourceFeatureType.getExtraColumns().getIndexOf(sourceGeomAtt.getName());

            } else {

                this.sourceGeometryIndex = sourceGeomAtt.getIndex();

            }

            this.targetGeometryIndex = targetGeomAtt.getIndex();

            this.sourceGeometryName = sourceGeomAtt.getName();

        }

        private int getGeometryColumnCount(FeatureType featureType) {

            int count = 0;

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

                if( featureType.getAttributeDescriptor(i).getType()==DataTypes.GEOMETRY ) {

                    count++;

                }

            }

            return count;

        }

        @Override

        public String getLastErrorMessage() {

            return this.lastErrorMessage;

        }

        @Override

        public int copyGeometry(

                Feature sourceFeature, 

                EditableFeature targetFeature

            ) {

            if( this.sourceGeometryIndex<0 || this.targetGeometryIndex<0 ) {

                return ExportServiceManager.FixGeometryStatus.STATE_OK;

            }

            Geometry geometry;

            if( this.isExtraColumn ) {

                geometry = sourceFeature.getGeometry(this.sourceGeometryName);            

            } else {

                geometry = sourceFeature.getGeometry(this.sourceGeometryIndex);            

            }

            ExportServiceManager.FixGeometryStatus check = serviceManager.fixGeometry(

                    this.parameters, 

                    this.coord_trans, 

                    geometry

            );

            if( check.getState() == ExportServiceManager.FixGeometryStatus.STATE_OK ) {

                targetFeature.setGeometry(this.targetGeometryIndex, check.getGeometry());

            }

            this.lastErrorMessage = check.getMessage();

            return check.getState();

        }

        @Override

        public boolean canProcessGeometry() {

            return this.sourceGeometryIndex>=0 && this.targetGeometryIndex>=0 ;

        }

        private FeatureAttributeDescriptor getFirstGeometryColumn(FeatureType featureType) {

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

                FeatureAttributeDescriptor descriptor = featureType.getAttributeDescriptor(i);

                if( descriptor.getType()==DataTypes.GEOMETRY ) {

                    return descriptor;

                }

            }

            return null;

        }

}