agsinternetbuffercalculator.java

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

package com.esri.solutions.jitk.common.analysis.buffer;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.Level;

import java.util.List;

import com.esri.adf.web.ags.util.AGSUtil;
import com.esri.adf.web.data.geometry.WebGeometry;
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.data.geometry.WebPoint;
import com.esri.adf.web.data.geometry.WebPolyline;
import com.esri.adf.web.data.geometry.WebSpatialReference;
import com.esri.arcgis.geometry.IGeometry;
import com.esri.arcgis.geometry.IPoint;
import com.esri.arcgis.geometry.Point;
import com.esri.arcgis.geometry.Polygon;
import com.esri.arcgis.geometry.IPolygon2;
import com.esri.arcgis.geometry.Polyline;
import com.esri.arcgis.geometry.Path;
import com.esri.arcgis.geometry.Ring;
import com.esri.arcgis.geometry.ISpatialReference;
import com.esri.arcgis.geometry.ITopologicalOperator;
import com.esri.arcgis.server.IServerContext;
import com.esri.arcgisws.Geometry;
import com.esri.arcgisws.PolygonN;
import com.esri.arcgisws.SpatialReference;
import com.esri.solutions.jitk.common.agslocal.AgsLocalContextCreator;
import com.esri.solutions.jitk.common.agslocal.IServerContextFactory;
import com.esri.solutions.jitk.common.geometry.DistanceConverter;

public class AgsInternetBufferCalculator extends AgsLocalContextCreator implements IBufferCalculator {	
	private static final Logger logger = LogManager.getLogger(AgsInternetBufferCalculator.class);
	
	public AgsInternetBufferCalculator(IServerContextFactory svrCtxFact) {
		super(svrCtxFact);
	}

	public Polyline convertWebPolyline(WebPolyline webPolyline, IServerContext serverContext){
		try{
			List<WebPath> paths = webPolyline.getPaths();
			Polyline polyline = (Polyline)serverContext.createObject(Polyline.getClsid());
			for (int i = 0; i < paths.size(); i++){
				WebPath webPath = (WebPath)paths.get(i);
				List<WebPoint> webPoints = webPath.getPoints();
				Path path = (Path)serverContext.createObject(Path.getClsid());
				for (int j = 0; j < webPoints.size(); j++){
					WebPoint webPoint = (WebPoint)webPoints.get(j);
					IPoint point = (Point)serverContext.createObject(Point.getClsid());
					point.setX(webPoint.getX());
					point.setY(webPoint.getY());
					path.addPoint(point, null, null);					
				}
				polyline.addGeometry((IGeometry)path, null, null);
			}
			return polyline;
		}catch(Exception e){
			logger.log(Level.ERROR, "Unable to convert polyline", e);
		}
		return null;
	}
	
	public Polygon convertWebPolygon(WebPolygon webPolygon, IServerContext serverContext){
		try{
			List<WebRing> rings = webPolygon.getRings();
			Polygon polygon = (Polygon)serverContext.createObject(Polygon.getClsid());
			for (int i = 0; i < rings.size(); i++){
				WebRing webRing = (WebRing)rings.get(i);
				List<WebPoint> webPoints = webRing.getPoints();
				Ring ring = (Ring)serverContext.createObject(Ring.getClsid());
				for (int j = 0; j < webPoints.size(); j++){
					WebPoint webPoint = (WebPoint)webPoints.get(j);
					IPoint point = (Point)serverContext.createObject(Point.getClsid());
					point.setX(webPoint.getX());
					point.setY(webPoint.getY());
					ring.addPoint(point, null, null);					
				}
				polygon.addGeometry((IGeometry)ring, null, null);
			}
			return polygon;
		}catch(Exception e){
			logger.log(Level.ERROR, "Unable to convert polygon", e);
		}
		return null;
	}
	
	public WebGeometry calculateBuffer(WebGeometry geoOrigin, double dDistance, int iUnits) 
		throws Exception {
		WebGeometry geoBuffer = null;
		
		try {
			if (dDistance > 0) {
				IServerContext serverContext = super.createContext();
				
				//Convert origin to point
				Geometry agsPt = (Geometry)AGSUtil.toAGSGeometry(geoOrigin);
				IGeometry ipGeoOrigin = (IGeometry) AGSUtil.createArcObjectFromStub(agsPt, serverContext);
				
				//Original code was: WebSpatialReference wsr = this.context.getSpatialReference();
				WebSpatialReference wsr = geoOrigin.getSpatialReference();
				
				if (wsr != null) {
					try {
						SpatialReference sr = AGSUtil.toAGSSpatialReference(wsr);
						ISpatialReference srAo = (com.esri.arcgis.geometry.ISpatialReference) AGSUtil.createArcObjectFromStub(sr, serverContext);
						
						logger.debug("Buffer resource coordinate system is: " + srAo.getName());
						ipGeoOrigin.setSpatialReferenceByRef(srAo);
					}
					catch(Exception e) {
						logger.warn("Unable to port spatial reference from WebGeometry to ArcObject geometry. Continuing to attempt buffer calculation", e);
					}					
				}				
				
				//Convert distance to ArcObject distance
				ISpatialReference ipSpatRef = ipGeoOrigin.getSpatialReference();
				double projDist = DistanceConverter.convertDistance(
						ipSpatRef, iUnits, dDistance, serverContext);
				
/*				
                //ADF bug: Prep geometry for buffer 
                if (!(ipGeoOrigin instanceof IPoint)) {
                	ITopologicalOperator2 ipTopoOp2 = (ITopologicalOperator2) ipGeoOrigin;
                	ipTopoOp2.setIsKnownSimple(false);
                	ipTopoOp2.simplify();

                	if ((ipGeoOrigin instanceof IPolygon) || (ipGeoOrigin instanceof IPolyline)) {
                		IPolycurve ipPolyCurve = (IPolycurve) ipGeoOrigin;
                		ipPolyCurve.densify(0, 0);
                		ipPolyCurve.generalize(0);
                    }    
                }
*/				
				IGeometry iBuffer = null; 
				if (geoOrigin instanceof WebPoint){
					//Buffer point and densify
					ITopologicalOperator ipTopoOp = (ITopologicalOperator) ipGeoOrigin;
					iBuffer = (IGeometry) ipTopoOp.buffer(projDist);
				}				
				if (geoOrigin instanceof WebPolyline){
					Polyline polyline = convertWebPolyline((WebPolyline)geoOrigin, serverContext);
//					polyline.setSpatialReferenceByRef(ipSpatRef);
					iBuffer = (IGeometry)((ITopologicalOperator)polyline).buffer(projDist);
				}
				if (geoOrigin instanceof WebPolygon){
					Polygon polygon = convertWebPolygon((WebPolygon)geoOrigin, serverContext);
//					polygon.setSpatialReferenceByRef(ipSpatRef);
					iBuffer = (IGeometry)((ITopologicalOperator)polygon).buffer(projDist);
				}
				IPolygon2 iPoly = (IPolygon2)iBuffer;
				iPoly.densify(0, 0);					
		
				//Convert ArcObject polygon to Web ADF polygon
				PolygonN poly = (PolygonN)AGSUtil.createStubFromArcObject(iPoly, PolygonN.class, serverContext);
				WebPolygon webPoly = (WebPolygon)AGSUtil.fromAGSGeometry(poly);
				geoBuffer = (WebGeometry)webPoly;	
			}
			else {
				geoBuffer = geoOrigin;
			}
		}
		catch (Exception ex) {
			throw ex;
		}
		finally {
			super.releaseContext();
		}
		
		return geoBuffer;
	}
}