querybuildertaskqueryutil.java

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

package com.esri.solutions.jitk.web.tasks.query.querybuilder;

import java.util.LinkedHashMap;
import org.apache.log4j.Logger;
import java.util.List;
import java.util.Iterator;
import com.esri.adf.web.data.query.WebQuery;
import com.esri.adf.web.data.query.QueryResult;
import com.esri.adf.web.data.geometry.WebExtent;
import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.geometry.WebCircle;
import com.esri.adf.web.data.geometry.WebPoint;
import com.esri.adf.web.data.geometry.WebOval;
import com.esri.adf.web.data.geometry.WebPointCollection;
import com.esri.adf.web.data.geometry.WebPolyline;
import com.esri.adf.web.data.geometry.WebPolygon;
import com.esri.adf.web.data.geometry.WebPath;
import com.esri.adf.web.data.geometry.WebRing;
import com.esri.adf.web.aims.data.AIMSMapResource;
import com.esri.adf.web.aims.data.AIMSMapFunctionality;
import com.esri.adf.web.ags.data.AGSMapResource;
import com.esri.adf.web.ags.data.AGSMapFunctionality;
import com.esri.arcgisws.MapLayerInfo;
import com.esri.aims.mtier.model.map.layer.Layer;
import com.esri.adf.web.data.query.IdentifyCriteria;

/**
 * This utility class converts WebGeometries to AGS/AIMS Geometries.
 * This utility class was necessary when the ADF code that performed these
 * operations was buggy.
 */
@SuppressWarnings("deprecation")
public class QueryBuilderTaskQueryUtil {
	private static Logger logger = Logger.getLogger(QueryBuilderTaskQueryUtil.class.getName());
	private static final double PI = 3.14159265;

	public QueryBuilderTaskQueryUtil(){
	}

	public static double angle2D(double x1, double y1, double x2, double y2){
		double dtheta, theta1, theta2;

		theta1 = Math.atan2(y1, x1);
		theta2 = Math.atan2(y2, x2);
		dtheta = theta2 - theta1;
		while (dtheta > PI)
			dtheta -= 2 * PI;
		while (dtheta < -PI)
			dtheta += 2 * PI;
		return dtheta;
	}

	public static boolean insidePolygon(WebPoint[] polygon, WebPoint p){
		double angle = 0;
		double x1, y1, x2, y2;

		for (int i = 0; i < polygon.length - 1; i++){
			x1 = polygon[i].getX() - p.getX();
			y1 = polygon[i].getY() - p.getY();
			x2 = polygon[i + 1].getX() - p.getX();
			y2 = polygon[i + 1].getY() - p.getY();
			angle += angle2D(x1, y1, x2, y2);
		}
		if (Math.abs(angle) < PI) return false;
		else return true;
	}

	private static WebExtent findExtent(WebGeometry webGeom){
		try{
			double minx, miny, maxx, maxy;
			minx = miny = maxx = maxy = -999999999.99;
			if (webGeom instanceof WebCircle){
				WebCircle webCircle = (WebCircle)webGeom;
				WebPoint center = webCircle.getCenter();
				minx = center.getX() - webCircle.getRadius();
				miny = center.getY() - webCircle.getRadius();
				maxx = center.getX() + webCircle.getRadius();
				maxy = center.getY() + webCircle.getRadius();
			}
			if (webGeom instanceof WebExtent){
				WebExtent ext = (WebExtent)webGeom;
				minx = ext.getMinX();
				miny = ext.getMinY();
				maxx = ext.getMaxX();
				maxy = ext.getMaxY();
			}
			if (webGeom instanceof WebOval){
				WebOval webOval = (WebOval)webGeom;
				WebPoint center = webOval.getCenter();
				minx = center.getX() - (webOval.getWidth() / 2);
				miny = center.getY() - (webOval.getHeight() / 2);
				maxx = center.getX() + (webOval.getWidth() / 2);
				maxy = center.getY() + (webOval.getHeight() / 2);
			}
			if (webGeom instanceof WebPoint){
				WebPoint webPoint = (WebPoint)webGeom;
				minx = maxx = webPoint.getX();
				miny = maxy = webPoint.getY();
			}
			if (webGeom instanceof WebPointCollection){
				List<WebPoint> wPts = ((WebPointCollection)webGeom).getPoints();
				Iterator<WebPoint> wIt = wPts.iterator();
				int cnt = 0; 
				while (wIt.hasNext()){
					WebPoint wPt = (WebPoint)wIt.next();					
					if (cnt == 0){
						minx = maxx = wPt.getX();
						miny = maxy = wPt.getY();
					}else{
						if (wPt.getX() < minx) minx = wPt.getX();
						if (wPt.getY() < miny) miny = wPt.getY();
						if (wPt.getX() > maxx) maxx = wPt.getX();
						if (wPt.getY() > maxy) maxy = wPt.getY();
					}
					cnt++;
				}
			}
			if (webGeom instanceof WebPolygon){
				WebPolygon wPoly = (WebPolygon)webGeom;
				List<WebRing> wRings = wPoly.getRings();
				Iterator<WebRing> wIt = wRings.iterator();
				int cnt = 0;
				while (wIt.hasNext()){
					WebRing wRing = (WebRing)wIt.next();
					WebPointCollection wPtColl = (WebPointCollection)wRing;
					List<WebPoint> wPts = wPtColl.getPoints();
					Iterator<WebPoint> wPIt = wPts.iterator();
					while (wPIt.hasNext()){
						WebPoint wPt = (WebPoint)wPIt.next();
						if (cnt == 0){
							minx = maxx = wPt.getX();
							miny = maxy = wPt.getY();
						}else{
							if (wPt.getX() < minx) minx = wPt.getX();
							if (wPt.getY() < miny) miny = wPt.getY();
							if (wPt.getX() > maxx) maxx = wPt.getX();
							if (wPt.getY() > maxy) maxy = wPt.getY();
						}
						cnt++;
					}
				}
			}
			if (webGeom instanceof WebPolyline){
				WebPolyline wLine = (WebPolyline)webGeom;
				List<WebPath> wPaths = wLine.getPaths();
				Iterator<WebPath> wIt = wPaths.iterator();
				int cnt = 0;
				while (wIt.hasNext()){
					WebPath wPath = (WebRing)wIt.next();
					WebPointCollection wPtColl = (WebPointCollection)wPath;
					List<WebPoint> wPts = wPtColl.getPoints();
					Iterator<WebPoint> wPIt = wPts.iterator();
					while (wPIt.hasNext()){
						WebPoint wPt = (WebPoint)wPIt.next();
						if (cnt == 0){
							minx = maxx = wPt.getX();
							miny = maxy = wPt.getY();
						}else{
							if (wPt.getX() < minx) minx = wPt.getX();
							if (wPt.getY() < miny) miny = wPt.getY();
							if (wPt.getX() > maxx) maxx = wPt.getX();
							if (wPt.getY() > maxy) maxy = wPt.getY();
						}
						cnt++;
					}
				}
			}
			return new WebExtent(minx, miny, maxx, maxy);
		}catch(Exception e){
			logger.error("Unable to find extent", e);
		}
		return null;
	}

	public static boolean checkFeatureGeometry(String spatialOperation, WebGeometry webGeom, String slayer, 
		LinkedHashMap<String, Object> resources, WebQuery webQuery){
		try{
			String[] slayerInfo = slayer.split("!");
			String sid = slayerInfo[0];
			String slayerName = "";
			Object sresource = resources.get(sid);
			String slyrId = slayerInfo[1];
			if (sresource instanceof AIMSMapResource){
				AIMSMapResource aimsMapResource = (AIMSMapResource)sresource;
				AIMSMapFunctionality aimsMapFunc = (AIMSMapFunctionality)(aimsMapResource).getFunctionality("map");
				Layer aimsLayer = aimsMapFunc.getLayer(slyrId);
				slayerName = aimsLayer.getName();
			}
			if (sresource instanceof AGSMapResource){
				AGSMapResource agsMapResource = (AGSMapResource)sresource;
				AGSMapFunctionality agsMapFunc = (AGSMapFunctionality)(agsMapResource).getFunctionality("map");
				MapLayerInfo mapLayer = agsMapFunc.getLayerInfo(Integer.parseInt(slyrId));
				slayerName = mapLayer.getName();
			}
			IdentifyCriteria ic = new IdentifyCriteria(webGeom);
			List<QueryResult> ssearchResults = webQuery.query(ic, QueryBuilderTaskUtil.getWebLayerInfoList(webQuery.getQueryLayers(), slayerName));
			if (ssearchResults.size() > 0 && spatialOperation.equalsIgnoreCase("intersects")) return true;
			// Just check the envelope...
			for (int i = 0; i < ssearchResults.size(); i++){
				QueryResult result = (QueryResult)ssearchResults.get(i);
				WebGeometry swebGeom = result.getHighlightGeometry();
				WebExtent ext = findExtent(webGeom);
				WebExtent sext = findExtent(swebGeom);
				if (sext.contains(new WebPoint(ext.getMinX(), ext.getMinY())) &&
					sext.contains(new WebPoint(ext.getMinX(), ext.getMaxY())) &&
					sext.contains(new WebPoint(ext.getMaxX(), ext.getMaxY())) &&
					sext.contains(new WebPoint(ext.getMaxX(), ext.getMinY()))) return true;
			}
		}catch(Exception e){
			logger.error("Unable to check feature geometry", e);
		}
		return false;
	}

	public static boolean checkWebGeometry(String operation, WebGeometry filterGeom, WebGeometry webGeom){
		try{
			if (operation.equalsIgnoreCase("")) return true;
			WebPolygon filterPoly = (WebPolygon)filterGeom;
			WebPointCollection ptColl = (WebPointCollection)filterPoly.getRing(0);
			List<WebPoint> pts = ptColl.getPoints();

			WebPoint[] polygon = new WebPoint[pts.size()];
			Iterator<WebPoint> it = pts.iterator();
			int idx = 0; 
			while (it.hasNext()){
				polygon[idx] = (WebPoint)it.next();
				idx++;
			}

			if (webGeom instanceof WebCircle){
				WebCircle webCircle = (WebCircle)webGeom;
				WebPoint center = webCircle.getCenter();
				return insidePolygon(polygon, center);
			}
			if (webGeom instanceof WebExtent){
				WebExtent ext = (WebExtent)webGeom;
				boolean inter = false;
				boolean within = true;
				for (int i = 0; i < polygon.length; i++){
					boolean contains = ext.contains(polygon[i]);
					if (contains) inter = true;
					else within = false;
				}
				if (operation.equalsIgnoreCase("intersects")) return inter;
				if (operation.equalsIgnoreCase("within")) return within;
			}
			if (webGeom instanceof WebOval){
				WebOval webOval = (WebOval)webGeom;
				WebPoint center = webOval.getCenter();
				return insidePolygon(polygon, center);
			}
			if (webGeom instanceof WebPoint){
				return insidePolygon(polygon, (WebPoint)webGeom);
			}
			if (webGeom instanceof WebPointCollection){
				List<WebPoint> wPts = ((WebPointCollection)webGeom).getPoints();
				boolean inter = false;
				boolean within = true;
				Iterator<WebPoint> wIt = wPts.iterator();
				while (wIt.hasNext()){
					WebPoint wPt = (WebPoint)wIt.next();
					boolean contains = insidePolygon(polygon, wPt);
					if (contains) inter = true;
					else within = false;
				}
				if (operation.equalsIgnoreCase("intersects")) return inter;
				if (operation.equalsIgnoreCase("within")) return within;
			}
			if (webGeom instanceof WebPolygon){
				WebPolygon wPoly = (WebPolygon)webGeom;
				boolean inter = false;
				boolean within = true;
				List<WebRing> wRings = wPoly.getRings();
				Iterator<WebRing> wIt = wRings.iterator();
				while (wIt.hasNext()){
					WebRing wRing = (WebRing)wIt.next();
					WebPointCollection wPtColl = (WebPointCollection)wRing;
					List<WebPoint> wPts = wPtColl.getPoints();
					Iterator<WebPoint> wPIt = wPts.iterator();
					while (wPIt.hasNext()){
						WebPoint wPt = (WebPoint)wPIt.next();
						boolean contains = insidePolygon(polygon, wPt);
						if (contains) inter = true;
						else within = false;
					}
				}
				if (operation.equalsIgnoreCase("intersects")) return inter;
				if (operation.equalsIgnoreCase("within")) return within;
			}
			if (webGeom instanceof WebPolyline){
				WebPolyline wLine = (WebPolyline)webGeom;
				boolean inter = false;
				boolean within = true;
				List<WebPath> wPaths = wLine.getPaths();
				Iterator<WebPath> wIt = wPaths.iterator();
				while (wIt.hasNext()){
					WebPath wPath = (WebRing)wIt.next();
					WebPointCollection wPtColl = (WebPointCollection)wPath;
					List<WebPoint> wPts = wPtColl.getPoints();
					Iterator<WebPoint> wPIt = wPts.iterator();
					while (wPIt.hasNext()){
						WebPoint wPt = (WebPoint)wPIt.next();
						boolean contains = insidePolygon(polygon, wPt);
						if (contains) inter = true;
						else within = false;
					}
				}
				if (operation.equalsIgnoreCase("intersects")) return inter;
				if (operation.equalsIgnoreCase("within")) return within;
			}
		}catch(Exception e){
			logger.error("Unable to check web geometry", e);
		}
		return false;
	}
}