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

 * 2008 Prodevelop S.L. main development

 */

package org.gvsig.geocoding.styles;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.geocoding.Address;

import org.gvsig.geocoding.geommatches.MatcherUtils;

import org.gvsig.geocoding.result.DissolveResult;

import org.gvsig.geocoding.result.GeocodingResult;

import org.gvsig.geocoding.result.GeomMatchResult;

import org.gvsig.geocoding.result.ScoredFeature;

/**

 * 

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 */

public class SimpleCentroid extends AbstractGeocodingStyle {

        @Override

        public Set<GeocodingResult> match(List inFeats, Address address) {

                Set<GeocodingResult> geocoRes = new TreeSet<GeocodingResult>();

                // catch the first element of the main Literal to get the field

                // descriptor

                // to make the dissolve

                FeatureAttributeDescriptor desc = (FeatureAttributeDescriptor) this

                                .getMainLiteral().get(0).getValue();

                // POINTs FEATURES

                if (((ScoredFeature) inFeats.get(0)).getDefaultGeometry()

                                .getDimension() == 0) {

                        geocoRes = createPointsFeaturesResult(inFeats);

                }

                // OTHER GEOMETRIES TYPES

                else {

                        // dissolve features selected

                        List<DissolveResult> disRes = this.dissolveScoredFeatures(desc,

                                        inFeats);

                        for (DissolveResult dis : disRes) {

                                GeomMatchResult matchres = new GeomMatchResult();

                                Point2D position = null;

                                Geometry geom = dis.getGeom();

                                // Points

                                if (geom.getDimension() == 0) {

                                        // TODO faltan los puntos

                                }

                                // Lines

                                if (geom.getDimension() == 1) {

                                        com.vividsolutions.jts.geom.Geometry geoJTS = MatcherUtils

                                                        .parseGeomGVToJTS(geom);

                                        position = MatcherUtils

                                                        .getLinePositionFromRelativeDistance(geoJTS, 50);

                                }

                                // Polys

                                if (geom.getDimension() == 2) {

                                        position = MatcherUtils.internalPointGeometry(geom);

                                }

                                matchres.setGeom(position);

                                matchres.setSources(dis.getScoredFeatures());

                                geocoRes.add(matchres);

                        }

                }

                return geocoRes;

        }

        /**

         * 

         * @param inFeats

         * @return

         */

        private Set<GeocodingResult> createPointsFeaturesResult(

                        List<ScoredFeature> inFeats) {

                Set<GeocodingResult> results = new TreeSet<GeocodingResult>();

                for (ScoredFeature feat : inFeats) {

                        GeomMatchResult res = new GeomMatchResult();

                        res.setGeom(feat.getDefaultGeometry());

                        List<ScoredFeature> sources = new ArrayList<ScoredFeature>();

                        sources.add(feat);

                        res.setSources(sources);

                        results.add(res);

                }

                return results;

        }

        /**

         * Dissolve features geometry behind one folder

         * 

         * @param field

         * @param features

         */

        public List<DissolveResult> dissolveScoredFeatures(

                        FeatureAttributeDescriptor field, List<ScoredFeature> features) {

                List<DissolveResult> listResults = new ArrayList<DissolveResult>();

                // Group geometries by main attribute

                HashMap<String, List<ScoredFeature>> dissolAttributes = MatcherUtils

                                .groupScoredFeaturesByAttribute(field, features);

                // For each group of features, to do geometries dissolve process getting

                // at the end one o more geometries

                for (Iterator<Map.Entry<String, List<ScoredFeature>>> iterator = dissolAttributes

                                .entrySet().iterator(); iterator.hasNext();) {

                        Map.Entry<String, List<ScoredFeature>> e = iterator.next();

                        List<ScoredFeature> feats = e.getValue();

                        // dissolve Lines (if first geometry of array is Line)

                        List<DissolveResult> geomsDissol = null;

                        if (feats.get(0).getDefaultGeometry().getDimension() == 1) {

                                geomsDissol = MatcherUtils.dissolveLinesJTS(feats);

                        }

                        // dissolve Polys (if first geometry of array is Poly)

                        if (feats.get(0).getDefaultGeometry().getDimension() == 2) {

                                geomsDissol = MatcherUtils.dissolvePolysJTS(feats);

                        }

                        // insert each dissolve result in the general array

                        for (DissolveResult dissolveResult : geomsDissol) {

                                listResults.add(dissolveResult);

                        }

                }

                return listResults;

        }

}