/ - Diff - Application: gvSIG desktop - gvSIG

     import org.gvsig.geocoding.address.ComposedAddress;
     import org.gvsig.geocoding.address.Literal;
     import org.gvsig.geocoding.address.NumberAddress;
     import org.gvsig.geocoding.index.FeatureIndexedEvent;
     import org.gvsig.geocoding.index.IndexListener;
     import org.gvsig.geocoding.pattern.GeocodingPattern;
     import org.gvsig.geocoding.result.GeocodingResult;
     import org.gvsig.geocoding.result.ScoredFeature;
-...
     	private Logger log = LoggerFactory.getLogger(LuceneGeocoderImpl.class);
     	private GeocodingPattern pattern = null;
     	private DataStore store = null;
     	@SuppressWarnings("unused")
     	private DataManager manager = null;
     	private int position = 0;
     	private IndexListener indexListener;
     	/*
     	 * This path is a temporal folder. This code is a copy of the
     	 * libRemoteServices and LibRaster
-...
+    	}
     	/**
     	 * Geocoding process
+    	 *
     	 * @param address
     	 * @return results
     	 */
     	public Set<GeocodingResult> geocode(Address address)
     			throws LocatorException, DataException {
-...
+    	}
     	/**
     	 * First scouting process, search literal elements in data store and return
     	 * a list with ok scored features
+    	 *
     	 * @param relationsLiteral
     	 * @param addressLiteral
-...
     		double minScore = getPattern().getSettings().getScore();
     		// Create index writer
     		IndexWriter indexWriter = null;
     		try {
     			indexWriter = createIndex(store, relationsLiteral);
     		} catch (Exception e) {
     			log.error("Error creating index", e);
+    		}
     		// if index writer is not null run search process
     		if (indexWriter != null) {
     			// search
     			Hits hits = null;
     		// search
     		Hits hits =  seachOnIndex(relationsLiteral, addressLiteral);
     		// if there are hits in search process
     		if (hits != null) {
     			// filter results
     			try {
     				hits = seachOnIndex(relationsLiteral, addressLiteral);
     				scorefeats = filterHitsByScore(store, hits, minScore);
     			} catch (Exception e) {
     				log.error("Error searching on index", e);
     				log.error("Error filtering hits by score", e);
     				scorefeats.clear();
+    			}
     			// if there are hits on search process
     			if (hits != null || hits.length() > 0) {
     				// filter
     				try {
     					scorefeats = filterHitsByScore(store, hits, minScore);
     				} catch (Exception e) {
     					log.error("Error filtering hits by score", e);
+    				}
+    			}
+    		}
     		return scorefeats;
-...
     	 * @param relationsLiteral
     	 * @param addressLiteral
     	 * @return
     	 * @throws CorruptIndexException
     	 * @throws IOException
     	 * @throws ParseException
     	 */
     	private Hits seachOnIndex(Literal relationsLiteral, Literal addressLiteral)
     			throws CorruptIndexException, IOException, ParseException {
+    			 {
     		log.info("Buscar ...");
     		IndexSearcher searcher = new IndexSearcher(tempDirectoryPath);
     		IndexSearcher searcher = null;
     		try {
     			searcher = new IndexSearcher(tempDirectoryPath);
     		} catch (Exception e) {
     			log.debug("Error building index searcher", e);
     			log.debug("Rebuild the index file because the initial index is wrong");
     			try {
     				this.indexer(store, relationsLiteral);
     			} catch (Exception e1) {
     				log.debug("Error building index searcher", e1);
     				return null;
+    			}
+    		}
     		if (searcher != null) {
     			String[] input = addressLiteral.getStringValuesArray();
     			String[] fields = relationsLiteral.getStringValuesArray();
     		String[] input = addressLiteral.getStringValuesArray();
     		String[] fields = relationsLiteral.getStringValuesArray();
     		Query query = MultiFieldQueryParser.parse(input, fields,
     				new StandardAnalyzer());
     		Hits hits = searcher.search(query);
     		return hits;
     			Query query = null;
     			try {
     				query = MultiFieldQueryParser.parse(input, fields,
     						new StandardAnalyzer());
     			} catch (ParseException e) {
     				log.debug("Error building the query", e);
     				return null;
+    			}
     			Hits hits = null;
     			if(query != null){
     				try {
     					hits = searcher.search(query);
     				} catch (IOException e) {
     					log.debug("Error in the searching process", e);
     					return null;
+    				}
+    			}
     			return hits;
     		} else {
     			return null;
+    		}
+    	}
     	/**
+    	 *
     	 * @param store
     	 * @param hits
     	 * @param score
     	 * @return
     	 * @throws IOException
     	 * @throws DataException
-...
     		FeatureStore fstore = (FeatureStore) store;
     		List<ScoredFeature> scoreFeats = new ArrayList<ScoredFeature>();
     		for (int i = 0; i < hits.length(); i++) {
     			if (hits.score(i) > score) {
     			if (hits.score(i) * 100 > score) {
     				Document doc = hits.doc(i);
     				String id = doc.get(GeocoID);
     				FeatureSet fset = fstore.getFeatureSet();
-...
+    	 *
     	 * @param store
     	 * @param relationsLiteral
     	 * @return
     	 * @throws DataException
     	 * @throws CorruptIndexException
     	 * @throws LockObtainFailedException
     	 * @throws IOException
     	 */
     	private IndexWriter createIndex(DataStore store, Literal relationsLiteral)
     	public void indexer(DataStore store, Literal relationsLiteral)
     			throws DataException, CorruptIndexException,
     			LockObtainFailedException, IOException {
     		log.info("Create indexes ...");
     		log.debug("Create indexes ...");
     		IndexWriter indexWriter = new IndexWriter(tempDirectoryPath,
     				new StandardAnalyzer(), true);
-...
     		Feature feat = null;
     		Iterator it = features.fastIterator();
     		// process situation
     		this.position = 0;
     		while (it.hasNext()) {
     			Document doc = new org.apache.lucene.document.Document();
-...
     				doc.add(field);
+    			}
     			indexWriter.addDocument(doc);
     			// throw indexed event
     			if(this.indexListener != null){
     				this.indexListener.featureIndexed(new FeatureIndexedEvent(this));
+    			}
     			// new position
     			this.position++;
+    		}
     		indexWriter.optimize();
     		return indexWriter;
+    	}
     	/**
+    	 *
     	 * @param listener
     	 */
     	public void registreIndexListener(IndexListener listener){
     		this.indexListener = listener;
+    	}
     	/**
+    	 *
     	 * @return
     	 */
     	public int getIndexPosition() {
     		return position;
+    	}
+    }

     public class Composed extends AbstractGeocodingStyle {
     	private static final Logger log = LoggerFactory.getLogger(Composed.class);
     	private static final Logger log = LoggerFactory.getLogger(Composed.class);
     	private List<Literal> intersectsLiterals = new ArrayList<Literal>();
-...
     									.geometryToJts(secFeat.getFeature()
     											.getDefaultGeometry());
     							if (mainGeomJTS.touches(secGeomJTS)) {
     								Point pto = MatcherUtils.intersectTwoLinesJTS(
     										mainGeomJTS, secGeomJTS);
     								GeomMatchResult res = new GeomMatchResult();
     								// geom
     								res.setGeom(pto);
     								// features scored
     								List<ScoredFeature> mainSources = new ArrayList<ScoredFeature>();
     								mainSources.add(mainFeat);
     								res.setMainSources(mainSources);
     								List<ScoredFeature> secSources = new ArrayList<ScoredFeature>();
     								secSources.add(secFeat);
     								res.setSecondSources(secSources);
     								// address
     								res.setAddress(getResultAddress(mainSources,
     										secSources, null));
     								results.add(res);
     								List<Point> ptos = MatcherUtils
     										.intersectTwoLinesJTS(mainGeomJTS,
     												secGeomJTS);
     								if (!(ptos.isEmpty())) {
     									for (int i = 0; i < ptos.size(); i++) {
     										GeomMatchResult res = new GeomMatchResult();
     										// geom
     										res.setGeom(ptos.get(i));
     										// features scored
     										List<ScoredFeature> mainSources = new ArrayList<ScoredFeature>();
     										mainSources.add(mainFeat);
     										res.setMainSources(mainSources);
     										List<ScoredFeature> secSources = new ArrayList<ScoredFeature>();
     										secSources.add(secFeat);
     										res.setSecondSources(secSources);
     										// address
     										res.setAddress(getResultAddress(
     												mainSources, secSources, null));
     										results.add(res);
+    									}
+    								}
+    							}
+    						}
+    					}
-...
     		return results;
+    	}
     	/**
+    	 *
     	 * @param mainSources
     	 * @param secSources
     	 * @return
     	 * @throws DataException
     	 * @throws DataException
     	 */
     	private ComposedAddress getResultAddress(List<ScoredFeature> mainSources,
     			List<ScoredFeature> secSources) throws DataException{
     			List<ScoredFeature> secSources) throws DataException {
     		// get the first element
     		Feature mainfeat = mainSources.get(0).getFeature();
     		Feature secfeat = secSources.get(0).getFeature();
     		Literal relLiteral = this.getRelationsLiteral();
     		Literal mainliteral = createLiteralFromFeature(mainfeat,relLiteral);
     		Literal secliteral = createLiteralFromFeature(secfeat,relLiteral);
     		Literal mainliteral = createLiteralFromFeature(mainfeat, relLiteral);
     		Literal secliteral = createLiteralFromFeature(secfeat, relLiteral);
     		ComposedAddress address = (ComposedAddress) new DefaultComposedAddress();
     		address.setMainLiteral(mainliteral);
     		List<Literal> intersectionLiteralList = new ArrayList<Literal>();
     		intersectionLiteralList.add(secliteral);
     		address.setIntersectionLiterals(intersectionLiteralList);
     		return address;
+    	}
     	/**
+    	 *
     	 * @return
     	 * @throws DataException
     	 * @throws DataException
     	 */
     	private Address getResultAddress(List<ScoredFeature> mainSources,
     			List<ScoredFeature> secSources, List<ScoredFeature> thiSources) throws DataException {
     			List<ScoredFeature> secSources, List<ScoredFeature> thiSources)
     			throws DataException {
     		ComposedAddress address = this.getResultAddress(mainSources, secSources);
     		ComposedAddress address = this
     				.getResultAddress(mainSources, secSources);
     		// get the first element
     		// get the first element
     		Feature thifeat = thiSources.get(0).getFeature();
     		if (thiSources != null) {
     			Feature thifeat = thiSources.get(0).getFeature();
     			Literal relLiteral = this.getRelationsLiteral();
     			Literal thiliteral = createLiteralFromFeature(thifeat, relLiteral);
     		Literal relLiteral = this.getRelationsLiteral();
     		Literal thiliteral = createLiteralFromFeature(thifeat,relLiteral);
     		address.getIntersectionLiterals().add(thiliteral);
     			address.getIntersectionLiterals().add(thiliteral);
+    		}
     		return address;
+    	}
-...
     		super.getRelationsLiteral().clear();
     		XMLEntity xml2 = xml.getChild(0);
     		super.getRelationsLiteral().setXMLEntity(xml2);
     		this.intersectsLiterals.clear();
     		for (int i = 1; i < xml.getChildrenCount(); i++) {
     			Literal lit = new DefaultLiteral();

     package org.gvsig.geocoding.address.impl;
     import java.util.ArrayList;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.Map.Entry;
     import org.gvsig.geocoding.address.ComposedAddress;
     import org.gvsig.geocoding.address.Literal;
-...
     	 * TODO check newliteral components match mainliteral ones
     	 */
     	public boolean isValidate(Literal newLiteral) {
     		return false;
     		Iterator it = super.getMainLiteral().entrySet().iterator();
     		Iterator it2 = newLiteral.entrySet().iterator();
     		try{
     		while (it.hasNext()) {
     			Entry entry1 = (Entry)it.next();
     			Entry entry2 = (Entry)it2.next();
     			String key1 = (String)entry1.getKey();
     			String key2 = (String)entry2.getKey();
     			if(key1.trim().compareTo(key2.trim())==0){
     				// true
+    			}
     			else{
     				return false;
+    			}
+    		}
     		}catch(Exception e){
     			return false;
+    		}
     		return true;
+    	}
     	/**

     import java.util.Set;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.geocoding.address.Address;
     import org.gvsig.geocoding.pattern.GeocodingPattern;
     import org.gvsig.geocoding.result.GeocodingResult;
     import org.gvsig.tools.locator.LocatorException;
-...
     	 */
     	public Set<GeocodingResult> geocode(Address address)
     			throws InitializeException, LocatorException, DataException;
     	/**
+    	 *
     	 * @param pattern
     	 */
     	public void setPattern(GeocodingPattern pattern);
     	/**
+    	 *
     	 * @param store
     	 */
     	public void setStore(DataStore store);
+    }

     /* 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.index;
     import java.util.EventObject;
     public class FeatureInxededEvent extends EventObject {
     	private static final long serialVersionUID = 1L;
     	private long positionFeature;
     	public long getPositionFeature() {
     		return positionFeature;
+    	}
     	public void setPositionFeature(long positionFeature) {
     		this.positionFeature = positionFeature;
+    	}
     	public FeatureInxededEvent(Object source) {
     		super(source);
     		// TODO Auto-generated constructor stub
+    	}
+    }

branches/v2_0_0_prep/libraries/libGeocoding/src/org/gvsig/geocoding/index/IndexListener.java
31	31
32	32	public interface IndexListener extends EventListener {
33	33
34		public void featureIndexed(FeatureInxededEvent e);
	34	public void featureIndexed(FeatureIndexedEvent e);
35	35	}

     import java.util.EventObject;
     import org.gvsig.geocoding.impl.LuceneGeocoderImpl;
     public class FeatureIndexedEvent extends EventObject {
-...
     	public long getPositionFeature() {
     		return positionFeature;
+    	}
+    	}
     	public void setPositionFeature(long positionFeature) {
     		this.positionFeature = positionFeature;
+    	}
     	public FeatureIndexedEvent(Object source) {
     		super(source);
     		// TODO Auto-generated constructor stub
+    	}
     		this.positionFeature = ((LuceneGeocoderImpl)source).getIndexPosition();
+    	}
+    }

     	 * @param geom2Jts
     	 * @return
     	 */
     	public static Point intersectTwoLinesJTS(
     	public static List<Point> intersectTwoLinesJTS(
     			com.vividsolutions.jts.geom.Geometry geom1Jts,
     			com.vividsolutions.jts.geom.Geometry geom2Jts) {
     		com.vividsolutions.jts.geom.Geometry interBBoxJTS = null;
     		com.vividsolutions.jts.geom.Geometry geomPointJTS = null;
     //		com.vividsolutions.jts.geom.Geometry interBBoxJTS = null;
     //		com.vividsolutions.jts.geom.Geometry geomPointJTS = null;
     		List<Point> points = new ArrayList<Point>();
     		if (geom1Jts != null && geom2Jts != null) {
     			interBBoxJTS = OverlayOp.overlayOp(geom1Jts.getEnvelope(), geom2Jts
     					.getEnvelope(), OverlayOp.INTERSECTION);
     			if (interBBoxJTS.getGeometryType().compareTo("LineString") == 0
     					|| interBBoxJTS.getGeometryType().compareTo("Polygon") == 0) {
     				log.debug("Intersect: Intersect two BBOX");
     				geomPointJTS = OverlayOp.overlayOp(geom1Jts, geom2Jts,
     						OverlayOp.INTERSECTION);
     				if (geomPointJTS.getGeometryType().compareTo("Point") == 0) {
     					log.debug("Intersect: Intersect in the point X= "
     							+ geomPointJTS.getCoordinate().x + " Y= "
     							+ geomPointJTS.getCoordinate().y);
     					Point pto = getPoint(geomPointJTS.getCoordinate().x,
     							geomPointJTS.getCoordinate().y);
     					return pto;
     				} else {
     					log.debug("Intersect: Two lines don't intersect");
     					return null;
     			com.vividsolutions.jts.geom.Geometry ugeoms = geom1Jts.intersection(geom2Jts);
     			if(ugeoms instanceof com.vividsolutions.jts.geom.Point){
     				com.vividsolutions.jts.geom.Point ptojts = (com.vividsolutions.jts.geom.Point)ugeoms;
     				Point pto = getPoint(ptojts.getCoordinate().x,
     						ptojts.getCoordinate().y);
     				points.clear();
     				points.add(pto);
     				return points;
     			}else if(ugeoms instanceof com.vividsolutions.jts.geom.MultiPoint){
     				com.vividsolutions.jts.geom.MultiPoint ptosjts = (com.vividsolutions.jts.geom.MultiPoint)ugeoms;
     				Coordinate[] coords = ptosjts.getCoordinates();
     				points.clear();
     				for (int i = 0; i < coords.length; i++) {
     					Coordinate coor = coords[i];
     					Point pto = getPoint(coor.x,coor.y);
     					points.add(pto);
+    				}
     			} else {
     				log.debug("Intersect: Two BBOX don't intersect");
     				return null;
     				return points;
+    			}
     //			interBBoxJTS = OverlayOp.overlayOp(geom1Jts.getEnvelope(), geom2Jts
     //					.getEnvelope(), OverlayOp.INTERSECTION);
     //			if (interBBoxJTS.getGeometryType().compareTo("LineString") == 0
     //					|| interBBoxJTS.getGeometryType().compareTo("Polygon") == 0) {
     //				log.debug("Intersect: Intersect two BBOX");
     //				geomPointJTS = OverlayOp.overlayOp(geom1Jts, geom2Jts,
     //						OverlayOp.INTERSECTION);
     //
     //				if (geomPointJTS.getGeometryType().compareTo("Point") == 0) {
     //
     //					Point pto = getPoint(geomPointJTS.getCoordinate().x,
     //							geomPointJTS.getCoordinate().y);
     //					points.add(pto);
     //					return points;
     //				} else if (geomPointJTS.getGeometryType().compareTo("MultiPoint") == 0) {
     //					log.debug("Intersect: Intersect );
     //					Point pto = getPoint(geomPointJTS.getCoordinate().x,
     //							geomPointJTS.getCoordinate().y);
     //					points.add(pto);
     //					return points;
     //				}
     //			} else {
     //				log.debug("Intersect: Two BBOX don't intersect");
     //				return null;
     //			}
+    		}
     		log.debug("Some Geometries are NULL  ......");
     		return null;
     		log.debug("Intersect: Two lines nor intersect or not touch");
     		return points;
+    	}
     	/**

Application: gvSIG desktop

Revision 32088