closestvertexfinder.java

esri的ArcGIS Server超级学习模板程序（for java）

package com.esri.solutions.jitk.common.geometry;

import java.util.List;

import org.apache.log4j.Logger;

import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.geometry.WebPath;
import com.esri.adf.web.data.geometry.WebPoint;
import com.esri.adf.web.data.geometry.WebPointCollection;
import com.esri.adf.web.data.geometry.WebPolygon;
import com.esri.adf.web.data.geometry.WebPolyline;
import com.esri.adf.web.data.geometry.WebRing;
import com.esri.solutions.jitk.common.math.PointDistanceCalculator;
import com.esri.solutions.jitk.web.data.geometry.WebArc;

public class ClosestVertexFinder {
	private static final Logger _logger = Logger.getLogger(ClosestVertexFinder.class);
	
	public ClosestVertexFinder() {
	}
	
	public WebPoint getClosestVertex(WebGeometry webGeo, WebPoint identifyPoint) 
		throws Exception {
		ClosestVertexResult closestVertex = null;
		
		if (webGeo instanceof WebPoint) {
			_logger.debug("Moving WebPoint");
			closestVertex = new ClosestVertexResult();
			closestVertex.setWebPoint((WebPoint) webGeo);
		}
		else if (webGeo instanceof WebPath) {
			_logger.debug("Moving WebPath");
			closestVertex = getClosestVertex((WebPath) webGeo, identifyPoint);
		}
		else if ((webGeo instanceof WebPolyline) && (!(webGeo instanceof WebArc))) {
			_logger.debug("Moving WebPolyline");
			closestVertex = getClosestVertex((WebPolyline) webGeo, identifyPoint);
		}					
		else if (webGeo instanceof WebPolygon) {
			_logger.debug("Moving WebPolygon");
			closestVertex = getClosestVertex((WebPolygon) webGeo, identifyPoint);
		}
		else if (webGeo instanceof WebPointCollection) {
			_logger.debug("Moving WebPointCollection");
			closestVertex = getClosestVertex((WebPointCollection) webGeo, identifyPoint);
		}
		else if (webGeo instanceof WebRing) {
			_logger.debug("Moving WebRing");
			closestVertex = getClosestVertex((WebRing) webGeo, identifyPoint);
		}			
		else {
			_logger.warn("Unsupported geometry type encountered");
			throw new Exception("Unsupported geomtry type encountered");
		}		
		
		return closestVertex.getWebPoint();
	}	
	
	public ClosestVertexResult getClosestVertex(WebPointCollection pointCol, WebPoint identifyPoint) {
		List<WebPoint> points = pointCol.getPoints();
		
		return getClosestVertex(points, identifyPoint);
	}	
	
	public ClosestVertexResult getClosestVertex(WebPolygon polygon, WebPoint identifyPoint) {
		List<WebRing> rings = polygon.getRings();
		ClosestVertexResult closestVertex = null;
		ClosestVertexResult currentVertex = null;
		
		for (WebRing ring : rings) {
			currentVertex = getClosestVertex(ring, identifyPoint);
			
			if (closestVertex == null) {
				closestVertex = currentVertex;
			}
			
			if (closestVertex.getDistance() > currentVertex.getDistance()) {
				closestVertex = currentVertex;
			}				
		}
		
		return closestVertex;
	}
	
	public ClosestVertexResult getClosestVertex(WebRing ring, WebPoint identifyPoint) {
		List<WebPoint> points = ring.getPoints();
		
		return getClosestVertex(points, identifyPoint);
	}	
	
	public ClosestVertexResult getClosestVertex(WebPolyline line, WebPoint identifyPoint) {
		List<WebPath> paths = line.getPaths();
		ClosestVertexResult closestVertex = null;
		ClosestVertexResult currentVertex = null;
		
		for (WebPath path : paths) {
			currentVertex = getClosestVertex(path, identifyPoint);
			
			if (closestVertex == null) {
				closestVertex = currentVertex;
			}
			
			if (closestVertex.getDistance() > currentVertex.getDistance()) {
				closestVertex = currentVertex;
			}
		}
		
		return closestVertex;
	}
	
	public ClosestVertexResult getClosestVertex(WebPath path, WebPoint identifyPoint) {
		List<WebPoint> points = path.getPoints();
		
		return getClosestVertex(points, identifyPoint);
	}
	
	public ClosestVertexResult getClosestVertex(List<WebPoint> points, WebPoint identifyPoint) {
		ClosestVertexResult closestVertex = null;
		double closestDistance = 0;
		double currentDistance = 0;
		
		for (WebPoint point : points) {
			currentDistance = getDistance(point, identifyPoint);
			
			if (closestVertex == null) {
				closestDistance = currentDistance;
				
				closestVertex = new ClosestVertexResult();
				closestVertex.setDistance(closestDistance);
				closestVertex.setWebPoint(point);
			}
			
			if (closestDistance > currentDistance) {
				closestDistance = currentDistance;
				
				closestVertex.setDistance(closestDistance);
				closestVertex.setWebPoint(point);				
			}
		}
		
		return closestVertex;	
	}
	
	public double getDistance(WebPoint point, WebPoint identifyPoint) {
		PointDistanceCalculator pdc = new PointDistanceCalculator();
		return pdc.getDistance(point, identifyPoint);
	}
}