gpmodel.java

实例实例实例实例实例实例实例实例实例实例实例实例实例实例实例实例

package com.esri.adf.ejb.sample.geoprocessing;

import java.rmi.RemoteException;

import javax.ejb.CreateException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

import com.esri.adf.ejb.geoprocessing.GeoprocessingEJB;
import com.esri.adf.ejb.geoprocessing.GeoprocessingEJBHome;
import com.esri.adf.ejb.map.MapEJB;
import com.esri.adf.ejb.map.MapEJBHome;
import com.esri.arcgisws.EsriGPParameterDirection;
import com.esri.arcgisws.EsriGPParameterType;
import com.esri.arcgisws.EsriJobStatus;
import com.esri.arcgisws.EsriUnits;
import com.esri.arcgisws.GPFeatureRecordSetLayer;
import com.esri.arcgisws.GPLinearUnit;
import com.esri.arcgisws.GPParameterInfo;
import com.esri.arcgisws.GPToolInfo;
import com.esri.arcgisws.GPValue;
import com.esri.arcgisws.GPResult;
import com.esri.arcgisws.MapLayerInfo;
import com.esri.arcgisws.MapServerInfo;
import com.esri.arcgisws.RecordSet;
import com.esri.arcgisws.EsriImageFormat;
import com.esri.arcgisws.EsriImageReturnType;
import com.esri.arcgisws.ImageDescription;
import com.esri.arcgisws.ImageDisplay;
import com.esri.arcgisws.ImageType;
import com.esri.arcgisws.MapDescription;
import com.esri.arcgisws.LayerDescription;
import com.esri.arcgisws.MapImage;
import com.esri.arcgisws.Field;
import com.esri.arcgisws.QueryFilter;
import com.esri.arcgisws.Fields;
import com.esri.arcgisws.PolygonN;
import com.esri.arcgisws.Record;
import com.esri.arcgisws.CircleElement;

public class GPModel 
{
	 private GeoprocessingEJB gpEJB;
	 private MapEJB mapEJB;	 
	 private double distance = 0; 
	 Context gpContext;
	 Context mapContext;
	 String mapName = null;
	 
	 private RecordSet recordSet = null;
	 CircleElement[] cElements = null;
	
	public GPModel() 
	{
	}
	
	public String execute() throws Exception
	{
		//get tool names
		String[] toolNames = gpEJB.getToolNames();	
		String executeTool = toolNames[1];		
		
		//get toolinfo, parameter info and init parameters
		GPToolInfo toolInfo = gpEJB.getToolInfo(executeTool);
		GPParameterInfo[] paramInfo = toolInfo.getParameterInfo();		
		GPValue[] values = initializeValues(paramInfo);
		
		//execute job and retrieve status
		String jobID = gpEJB.submitJob(executeTool, values);
		EsriJobStatus jobStatus = gpEJB.getJobStatus(jobID);
		String status = jobStatus.getValue();		
		
		//wait till job execution succeeds 
		while(!status.equalsIgnoreCase(EsriJobStatus._esriJobSucceeded))
		{
			Thread.sleep(1000);
			jobStatus = gpEJB.getJobStatus(jobID);
			status = jobStatus.getValue();
			
			if(status.equalsIgnoreCase(EsriJobStatus._esriJobFailed))
			{
				break;
			}
			
		}
		
		if(!status.equalsIgnoreCase(EsriJobStatus._esriJobSucceeded))
		{
			jobID = null;
		}			
	
		return jobID;
	}			
	
	public void processResult(String jobID) throws Exception
	{
		String[] param = new String[1];
		param[0] = "outputBuffer";
		
		GPResult gpResult = gpEJB.getJobResult(jobID, param, null);		
		GPValue[] resultValues = gpResult.getValues();
								
		GPFeatureRecordSetLayer resultFC = (GPFeatureRecordSetLayer) resultValues[0];					
		
		RecordSet resultRecordSet = resultFC.getRecordSet();
		Record[] records = resultRecordSet.getRecords();
							
		Fields fields = resultRecordSet.getFields();
		Field[] fieldArray = fields.getFieldArray();
		int shapeFieldIndex = 0;
		for(int j = 0; j < fieldArray.length; j++)
		{
			if(fieldArray[j].getName().equalsIgnoreCase("Shape"))
			{
				shapeFieldIndex = j;
				break;
			}
		}	

		int numRecords = records.length;
		PolygonN[] polygons = new PolygonN[numRecords];
		cElements = new CircleElement[numRecords];
		for(int k = 0; k < numRecords; k++)
		{
			Object[] values = records[k].getValues();
			polygons[k] = (PolygonN) values[shapeFieldIndex];	
			cElements[k] = new CircleElement();
			cElements[k].setRectangle(polygons[k]);			
		}
	}
	
	public byte[] getMapMimeData() 
	{	
		try
		{
			String mapName = mapEJB.getDefaultMapName();
			
			MapDescription mapDescription = mapEJB.getServerInfo(mapName).getDefaultMapDescription();
			LayerDescription[] tempLD = mapDescription.getLayerDescriptions();
			
			LayerDescription[] layerdescription = new LayerDescription[1];
			layerdescription[0] = tempLD[2];
			
			mapDescription.setCustomGraphics(cElements);
			mapDescription.setLayerDescriptions(layerdescription);
			
	        ImageType type = new ImageType();
	        type.setImageFormat(EsriImageFormat.esriImageJPG);
	        type.setImageReturnType(EsriImageReturnType.esriImageReturnMimeData);

	        ImageDisplay display = new ImageDisplay();
	        display.setImageHeight(600);
	        display.setImageWidth(600);
	        display.setImageDPI(96D);

	        ImageDescription imageDescription = new ImageDescription();
	        imageDescription.setImageType(type);
	        imageDescription.setImageDisplay(display);
	        
	        MapImage mapImage = mapEJB.exportMapImage(mapDescription, imageDescription);
	        mapDescription.getMapArea().setExtent(mapImage.getExtent());
	        
	        return mapImage.getImageData();
		}
		catch (Exception ex) 
		{
			ex.printStackTrace();
			return null;
		}
	}	
	
	public GPValue[] initializeValues(GPParameterInfo[] paramInfo) throws Exception
	{	
		GPValue[] values = new GPValue[paramInfo.length];
	
		for(int i = 0; i < paramInfo.length; i++)
		{
			if(paramInfo[i].getDirection() == EsriGPParameterDirection.esriGPParameterDirectionInput &&
					paramInfo[i].getParamType() == EsriGPParameterType.esriGPParameterTypeRequired)
			{	
				if(paramInfo[i].getDataType().equalsIgnoreCase("GPFeatureRecordSetLayer"))
				{                	
					GPFeatureRecordSetLayer gpFeatureRS = new GPFeatureRecordSetLayer();                                       
					gpFeatureRS.setRecordSet(recordSet);
	                
					paramInfo[i].setValue(gpFeatureRS);
				}
	
				if (paramInfo[i].getDataType().equalsIgnoreCase("GPLinearUnit"))
				{
					GPLinearUnit lu = new GPLinearUnit();
					lu.setUnits(EsriUnits.esriMiles);
					lu.setValue(distance);
	
					paramInfo[i].setValue(lu);
				}
			 }
	
			 values[i] = paramInfo[i].getValue();
		}
		return values;
	}	
	
	public void setInputFC(String mapJNDIName) throws CreateException, NamingException, RemoteException, Exception
	{
		initializeMapEJB(mapJNDIName);
		recordSet = getInputRecordSet();
	}
	
	public RecordSet getInputRecordSet() throws Exception 
	{	
		String mapName = mapEJB.getDefaultMapName();	
		MapServerInfo serverInfo = mapEJB.getServerInfo(mapName);
		MapLayerInfo[] layerInfo = serverInfo.getMapLayerInfos();
		int inputLayerIndex = -1;
		
		String layerName = null;
		for(int i = 0; i < layerInfo.length; i++) 
		{
			layerName = layerInfo[i].getName();
			String type = layerInfo[i].getLayerType();
			if(layerName.equalsIgnoreCase("InputPoint") && type.equalsIgnoreCase("Feature Layer")) 
			{				
				inputLayerIndex = i;
				break;
			}
		}
			
		/*String stateAbbr = "CA";
        QueryFilter queryFilter = new QueryFilter();
        String query = "'STATE_ABBR' = '" + stateAbbr + "'";
        queryFilter.setWhereClause(query);*/

        RecordSet recordSet = mapEJB.queryFeatureData(mapName, inputLayerIndex, null);
				
		return recordSet;
	}	
	
	public void setDistance(double distance)
	{
		this.distance = distance;
	}	

	public void closeContext()
	{
		try
		{
			gpContext.close();
			mapContext.close();
		}
		catch(NamingException ne)
		{
			ne.printStackTrace();
		}
	}
	
	public void initializeGPEJB(String gpJNDIName) throws CreateException, NamingException, RemoteException
	{
		gpContext = new InitialContext();
		Object ref = gpContext.lookup(gpJNDIName);        
		GeoprocessingEJBHome gpEJBHome = (GeoprocessingEJBHome) PortableRemoteObject.narrow(ref, GeoprocessingEJBHome.class);
		gpEJB = gpEJBHome.create();		       
	}
		
	private void initializeMapEJB(String mapJNDIName) throws CreateException, NamingException, RemoteException 
	{
		mapContext = new InitialContext();
		Object ref = mapContext.lookup(mapJNDIName);
		MapEJBHome home = (MapEJBHome) PortableRemoteObject.narrow(ref, MapEJBHome.class);
		mapEJB = home.create();		
	}		
}