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

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

import org.gvsig.geocoding.RelationsComponent;

import org.gvsig.geocoding.geommatches.MatcherUtils;

import org.gvsig.geocoding.result.GeocodingResult;

import org.gvsig.geocoding.result.GeomMatchResult;

import org.gvsig.geocoding.result.ScoredFeature;

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

/**

 * 

 * 

 * @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 DoubleRange extends AbstractRange {

        private static final String FIRSTLEFTNUMBER = "firstleftnumber";

        private static final String FIRSTRIGHTNUMBER = "firstrightnumber";

        private static final String LASTLEFTNUMBER = "lastleftnumber";

        private static final String LASTRIGHTNUMBER = "firstrightnumber";

        private RelationsComponent firstLeftNumber;

        private RelationsComponent firstRightNumber;

        private RelationsComponent lastLeftNumber;

        private RelationsComponent lastRightNumber;

        /**

         * Get relation component that define the field of data source that it has

         * the first left number of the feature

         * 

         * @return

         */

        public RelationsComponent getFirstLeftNumber() {

                return firstLeftNumber;

        }

        /**

         * Set relation component that define the field of data source that it has

         * the first left number of the feature

         * 

         * @param firstLeftNumber

         */

        public void setFirstLeftNumber(RelationsComponent firstLeftNumber) {

                this.firstLeftNumber = firstLeftNumber;

        }

        /**

         * Get relation component that define the field of data source that it has

         * the first right number of the feature

         * 

         * @return

         */

        public RelationsComponent getFirstRightNumber() {

                return firstRightNumber;

        }

        /**

         * Set relation component that define the field of data source that it has

         * the first right number of the feature

         * 

         * @param firstRightNumber

         */

        public void setFirstRightNumber(RelationsComponent firstRightNumber) {

                this.firstRightNumber = firstRightNumber;

        }

        /**

         * Get relation component that define the field of data source that it has

         * the last left number of the feature

         * 

         * @return

         */

        public RelationsComponent getLastLeftNumber() {

                return lastLeftNumber;

        }

        /**

         * Set relation component that define the field of data source that it has

         * the last left number of the feature

         * 

         * @param lastLeftNumber

         */

        public void setLastLeftNumber(RelationsComponent lastLeftNumber) {

                this.lastLeftNumber = lastLeftNumber;

        }

        /**

         * Get relation component that define the field of data source that it has

         * the last right number of the feature

         * 

         * @return

         */

        public RelationsComponent getLastRightNumber() {

                return lastRightNumber;

        }

        /**

         * Set relation component that define the field of data source that it has

         * the last right number of the feature

         * 

         * @param lastRightNumber

         */

        public void setLastRightNumber(RelationsComponent lastRightNumber) {

                this.lastRightNumber = lastRightNumber;

        }

        /**

         * Get the persistent state of the doublerange and append to the passed

         * state.

         * 

         * @param state

         */

        @Override

        public PersistentState getState() throws PersistenceException {

                return AbstractPersistenceManager.getState(this);

        }

        /**

         * Load the state of the doublerange over the passed state.

         * 

         * @param state

         */

        @Override

        public void loadState(PersistentState state) throws PersistenceException {

                state.setTheClass(this);

                state.set(FIRSTLEFTNUMBER, this.firstLeftNumber);

                state.set(FIRSTRIGHTNUMBER, this.firstRightNumber);

                state.set(LASTLEFTNUMBER, this.lastLeftNumber);

                state.set(LASTRIGHTNUMBER, this.lastRightNumber);

        }

        /**

         * Set the state of the doublerange from the state passed as parameter.

         * 

         * @param state

         */

        @Override

        public void setState(PersistentState state) throws PersistenceException {

                this.firstLeftNumber = (RelationsComponent) state.get(FIRSTLEFTNUMBER);

                this.firstRightNumber = (RelationsComponent) state

                                .get(FIRSTRIGHTNUMBER);

                this.lastLeftNumber = (RelationsComponent) state.get(LASTLEFTNUMBER);

                this.lastRightNumber = (RelationsComponent) state.get(LASTRIGHTNUMBER);

        }

        /**

         * spatial search over the geometries

         * 

         * @param lists

         *            list of lists with ScoredFeatures

         * @param address

         * @return

         */

        @Override

        public Set<GeocodingResult> match(List<List<ScoredFeature>> inLists,

                        Address address) {

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

                FeatureAttributeDescriptor firstLeftNumberDesc = this

                                .getFirstLeftNumber().getValue();

                FeatureAttributeDescriptor lastLeftNumberDesc = this

                                .getLastLeftNumber().getValue();

                FeatureAttributeDescriptor firstRightNumberDesc = this

                                .getFirstRightNumber().getValue();

                FeatureAttributeDescriptor lastRightNumberDesc = this

                                .getLastRightNumber().getValue();

                // get the list

                List<ScoredFeature> inFeats = inLists.get(0);

                int number = ((NumberAddress) address).getNumber();

                for (ScoredFeature feat : inFeats) {

                        int firstL = feat.getInt(firstLeftNumberDesc.getName());

                        int lastL = feat.getInt(lastLeftNumberDesc.getName());

                        int firstR = feat.getInt(firstRightNumberDesc.getName());

                        int lastR = feat.getInt(lastRightNumberDesc.getName());

                        // Number even (Par)

                        if (number % 2 == 0) {

                                // Left numbers - EVEN // right numbers - ODD

                                if (firstL % 2 == 0) {

                                        if (number >= firstL && number <= lastL) {

                                                // create result

                                                GeomMatchResult res = calculatePosition(feat, number,

                                                                firstL, lastL);

                                                // add result to the list

                                                outFeats.add(res);

                                        }

                                }

                                // Left numbers - ODD // right numbers - EVEN

                                else {

                                        if (number >= firstR && number <= lastR) {

                                                // create result

                                                GeomMatchResult res = calculatePosition(feat, number,

                                                                firstR, lastR);

                                                // add result to the list

                                                outFeats.add(res);

                                        }

                                }

                        }

                        // number odd (Impar)

                        else {

                                // Left numbers - EVEN // right numbers - ODD

                                if (firstL % 2 == 0) {

                                        if (number >= firstR && number <= lastR) {

                                                // create result

                                                GeomMatchResult res = calculatePosition(feat, number,

                                                                firstR, lastR);

                                                // add result to the list

                                                outFeats.add(res);

                                        }

                                }

                                // Left numbers - ODD // right numbers - EVEN

                                else {

                                        if (number >= firstL && number <= lastL) {

                                                // create result

                                                GeomMatchResult res = calculatePosition(feat, number,

                                                                firstL, lastL);

                                                // add result to the list

                                                outFeats.add(res);

                                        }

                                }

                        }

                }

                return outFeats;

        }

        /**

         * Calculate the relative distance in line

         * 

         * @param number

         * @param first

         * @param last

         * @return

         */

        private int calculateRelativeDistance(int number, int first, int last) {

                int total = Math.abs(last - first);

                int ini = Math.abs(number - first);

                return (ini * 100) / total;

        }

        /**

         * calculate the position

         * 

         * @param feat

         * @param number

         * @param first

         * @param last

         * @return

         */

        private GeomMatchResult calculatePosition(ScoredFeature feat, int number,

                        int first, int last) {

                Geometry geom = feat.getDefaultGeometry();

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

                                .parseGeomGVToJTS(geom);

                int relative = calculateRelativeDistance(number, first, last);

                Point2D position = MatcherUtils.getLinePositionFromRelativeDistance(

                                geJTS, relative);

                // create result

                GeomMatchResult res = new GeomMatchResult();

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

                list.add(feat);

                res.setGeom(position);

                res.setSources(list);

                return res;

        }

        /**

         * Calculate the position with a offset positive or negative

         * 

         * @param feat

         * @param number

         * @param first

         * @param last

         * @param offset

         * @return

         */

        private GeomMatchResult calculateOffsetPosition(ScoredFeature feat,

                        int number, int first, int last, int offset) {

                Geometry geom = feat.getDefaultGeometry();

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

                                .parseGeomGVToJTS(geom);

                int relative = calculateRelativeDistance(number, first, last);

                Point2D position = MatcherUtils.getLinePositionFromRelativeDistance(

                                geJTS, relative);

                // create result

                GeomMatchResult res = new GeomMatchResult();

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

                list.add(feat);

                res.setGeom(position);

                res.setSources(list);

                return res;

        }

}