Building a custom geoprocessing tool using Eclipse IDE wizard

In this topic

• About building a custom geoprocessing tool in Eclipse IDE
• Create a Java project
• Auto-generate a geoprocessing tool implementation
• Specify the license requirements and create a help file
• Define the tool's operation
• Export the tool as a JAR file
• Deploy the tool
• Consume the tool

About building a custom geoprocessing tool in Eclipse IDE

• Creating a custom function tool class
• Creating a custom function factory class

1. JDK version 1.6.30 is installed on your computer and <JDK Home>/bin is added to the PATH environment variable.
   
2. The Java ArcObjects SDK 10.1 is installed on your computer. The SDK provides access to libraries required for developing ArcObjects Java extensions, as well ArcGIS Eclipse plugins that hold Java extension creation and export wizards.
   
3. ArcGIS Eclipse plugins are installed in your copy of Eclipse. The minimum supported version of Eclipse at ArcGIS 10.1 is Helios Update 2 and Indigo Update 1. For instructions on how to install ArcGIS Eclipse plugins, see the "Using ESRI Eclipse Plugins" topic in "Developing Desktop Applications" -> "Using ESRI Eclipse Plugins" section of the ArcGIS Java Developer Help.

4. A Java project is already created and the Arcobjects library is added to its build path. The Arcobjects library is available as part of the ArcGIS Eclipse plugins.

Auto-generate a geoprocessing tool implementation

1. Open Eclipse IDE. With your Java project open, click File, click New, and click Other as shown in the following screen shot:
   
   
   
   The New, Select a wizard dialog box opens.

2. Expand the ESRI Templates -> ArcGIS Extensions, select Geoprocessing Tool, and click Next as shown in the following screen shot:

The New Geoprocessing Extension, Geoprocessing Tool dialog box opens. 

3. Type the name, or browse to the source folder, of the Java project you created.
4. Type in or browse to the Java Package name.
5. Fill in the tool Name, Display Name, and Description parameters as shown in the following screen shot:
   
   
   
   A Java class for the geoprocessing function tool is created in the source folder and package.
6. To change the function factory default settings, click the Advanced tab, check the Rename Function Factory or use an existing Function Factory check box, and type in the function factory name to which the tool belongs. Click the browse button if the custom function factory already exists in the same project.
7. Type in the Toolset category and click Next as shown in the following screen shot:
   
   
   
   The Add Geoprocessing Input Parameters dialog box opens.
   
   The Delete Features tool can delete features from a feature class, a feature layer, or a shapefile. Features are deleted based on the SQL Expression you provide. The parameters for the Delete Features tool are as follows:
• Input parameters
• in_features—A feature layer (.lyr) file or feature class from which the features will be deleted
• in_SQLExpression—The SQL expression dependent on the in_features parameter that queries the features to be deleted
• Output Parameter
• out_feature—The derived output feature class
8. To create these parameters, in the Add Geoprocessing Input Parameters dialog box, click New as shown in the following screen shot:
   
   
   
   The Parameter Properties dialog box opens.
9. Define the Name, Display Name, and Description parameter properties for in_features.
10. For the Data Type parameter, click the browse button. The Geoprocessing Data Types dialog box opens so you can select the appropriate parameter values. The in_feature parameter accepts feature classes and feature layers.
11. Select the DEFeatureClass and GPFeatureLayer values as shown in the following screen shot:
    
    
    
    If you select more than one value for the parameter, the wizard automatically designates it a composite data type. For more information about data types, see Defining data types for tool parameters.
    
    The Direction parameter property identifies whether the parameter is an input or an output parameter. Since you are creating input features, the wizard automatically identifies it as input.
12. Select Required from the Type drop-down box since in_features is a required parameter for execution of the tool. For more information about setting parameter properties, see Creating a custom function tool class.
13. Click OK. The in_features parameter that you created is listed under Input Parameters as shown in the following screen shot:
    
    
    
14. Click New to create another input parameter using the following parameter properties:
• Name: in_sqlExpression
• Display Name: Input SQL Expression
• Description: The SQL Expression to select the features to be deleted
• Data Type: GPSQLExpression
• Direction: Input
• Type: Required
• Dependency: in_Features (The SQL expression is dependent on the input features.)
The Parameter Properties dialog box will look like the following screen shot:


15. Click OK.
    The Add Geoprocessing Input Parameters dialog box opens.
16. Click Next as shown in the following screen shot:
    
    
    
    The Add Geoprocessing Output Parameters dialog box opens. 
17. Click New. See the following screen shot:
    
    
    
    The Parameter Properties dialog box opens.
18. Fill in the parameter properties for the out_features output parameter as shown in the following screen shot:
    
    
    
    The Direction property is defined as output by the wizard. This property is disabled on the dialog box and cannot be modified. The Type property is defined as derived because the out_features parameter is dependent on the in_features parameter. 
19. Click OK. The Add Geoprocessing Output Parameters dialog box opens as shown in the following screen shot. The out_features parameter is now listed under Output Parameters.
20. Click Next.
    
     

Specify the license requirements and create a help file

1. In the Specify help and license information dialog box, select the appropriate product license and extension license required for the operation of your tool.
2. If necessary, modify the default tool help file name that will be created by the wizard at <EngineInstallDir>\help\gp.
3. Click Finish.
   
   These steps are shown in the following screen shot:
   
   
   
   The wizard creates the custom geoprocessing function tool class and the custom function factory Java class in the specified Eclipse project based on your inputs. The wizard also auto-generates some of the method implementation based on those inputs as shown in the following screen shot:
   
   
   
   The custom function tool class and the getName(), getDisplayName(), and getFullName() implementations are generated by the information you provided in the Geoprocessing Tool dialog boxes. The getParameterInfo() implementation is based on the input and output parameter properties you provided in the Add Geoprocessing Input Parameters and Add Geoprocessing Output Parameters dialog boxes. The getMetaDataFile() and isLicensed() implementations are based on the information you provided in the Specify help and license information dialog box.
   
   The @ArcGISExtension annotation is added to your class definition. The auto-generated getName() method returns the function factory name that you provided. The getFunction() method returns the function tool associated with the factory and the getFunctionName() and getFunctionNames() methods create FunctionName objects based on the input tools created through the wizard.

Define the tool's operation

1. Check for an overwrite output value since the output parameter (out_features) is a derived type parameter and it overwrites the input parameter data (in_features).
2. Unpack the parameter values.
3. Create a query based on the SQL Expression and delete the features.

public class CustomDeleteFeatures extends BaseGeoprocessingTool{

    //...

    /**
     * Execute the tool.
     */
    public void execute(IArray paramvalues, ITrackCancel trackcancel,
        IGPEnvironmentManager envMgr, IGPMessages messages){
        try{
            //Get the overwrite output value. 
            IGeoProcessorSettings gpEnv = new IGeoProcessorSettingsProxy(envMgr);
            if (!gpEnv.isOverwriteOutput()){
                messages.addError(esriGPMessageSeverity.esriGPMessageSeverityError, 
                    "The Geoprocessing settings did not allow OverwriteOutput");
            }
            if (messages.getMaxSeverity() ==
                esriGPMessageSeverity.esriGPMessageSeverityError){
                return ;
            }
            else{
                //Input features parameter.
                IGPParameter inputFeaturesParameter = (IGPParameter)
                    paramvalues.getElement(0);
                IGPValue inputFeaturesValue = this.gpUtilities.unpackGPValue
                    (inputFeaturesParameter);
                //Retrieve the input as a feature class.
                IFeatureClass[] ifc = new IFeatureClass[1];
                ifc[0] = new IFeatureClassProxy();
                this.gpUtilities.decodeFeatureLayer(inputFeaturesValue, ifc, null);
                FeatureClass inputFeatureClass = new FeatureClass(ifc[0]);

                //SQL Expression parameter.
                IGPParameter expressionParameter = (IGPParameter)
                    paramvalues.getElement(1);
                IGPValue expressionValue = this.gpUtilities.unpackGPValue
                    (expressionParameter);
                String expression = expressionValue.getAsText();
                messages.addMessage("\tDeleting selected feature(s)...");

                //Delete the features.
                Workspace wsEdit = null;
                try{
                    wsEdit = new Workspace(inputFeatureClass.getWorkspace());
                    wsEdit.startEditing(false);
                    wsEdit.startEditOperation();
                    messages.addMessage(
                        "\nexecute() in DeleteFeatures: Num features before delete :" + inputFeatureClass.featureCount(null));
                    //Use the SQL Expression provided to determine the features to delete.
                    QueryFilter deleteFilter = new QueryFilter();
                    deleteFilter.setWhereClause(expression);
                    inputFeatureClass.deleteSearchedRows(deleteFilter);
                    messages.addMessage(
                        "\nexecute() in DeleteFeatures: Num features after delete : " + inputFeatureClass.featureCount(null));
                    wsEdit.stopEditOperation();
                    wsEdit.stopEditing(true);
                }
                catch (Exception e){
                    if (wsEdit != null && wsEdit.isBeingEdited()){
                        wsEdit.stopEditing(false);
                    }
                    e.printStackTrace();
                }
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }

    //...
}

Deploy the tool

1. Deploy the tool to Desktop
2. Execute it successfully.
3. Click Geoprocessing menu -> Results. The Results window will open up.
4. Expand Current Session. Right click on your custom GP tool (DeleteFeatures, in the screen shot below), and click "Share As -> Geoprocessing Service.

5. Publish the tool as a GP service by following the publishing wizard. This workflow is common to custom and as well as System GP tools. For more details on this workflow, please consult the Geoprocessing documentation in ArcGIS Resource Center.

Consume the tool

See Also: