TitlePages

Showing posts with label Script tool. Show all posts
Showing posts with label Script tool. Show all posts

Thursday, 22 January 2015

ArcFm Auto Updaters to Update the Shape Length of the Feature

Schneider electric

Update the Shape Length of the Poly line Feature

Special Auto Up-daters

A special Auto Up-daters differs from the attribute Auto Up-daters in that it is not associated with a field/event combination but rather a feature/event combination. A special Auto Up-daters can be associated to the On Feature Create, On Feature Update, or On Feature Delete events of a feature.

Special Auto Up-daters are not limited to simple field updates like attribute Auto Up-daters. Rather, they can be written to perform a wide array of tasks such as writing out text files, updating records in a remote database, sending emails - just about anything that you would need to programmatically do in response to a feature/object.

IMMSpecialAUStrategyEx Interface




  1. Do the following steps to start with AutoUpdaters.
  2. Start your Visual Studio 2010 or More 
  3. Create a New Project of Type base Command from ArcGIS tab .Choose the Programming Language of your comfort(VB or C#.Net)
  4. Give a Name to the Project and your can see base class library with your dll registered function with Unique Code GUID.
  1. To get the Functionality of the Special AutoUpdaters in your code implement the Specific Interface ie. IMMSpecialAUStrategyEx Interface


public class ShapeLengthAU : IMMSpecialAUStrategyEx
    {

        private string _name;
//Name is a required parameter for the Implemented Interface
        public string Name
        {
            get
            {
                if (string.IsNullOrEmpty(_name))
                {
                    _name =”Name of your Autoupdater
                }
                return _name;
            }
        }

        
        public void Execute(IObject obj, mmAutoUpdaterMode eAUMode, mmEditEvent editEvent)
        {
            IPCursor pCursor = null;
            try
            {
//Autoupdater will update only when the EditEvent is of Type like FeatureCreate,FeatureSplit,FeatureUpdate
                if (editEvent == mmEditEvent.mmEventFeatureCreate || editEvent == mmEditEvent.mmEventFeatureSplit || editEvent == mmEditEvent.mmEventFeatureUpdate)
                {
                    IFeature pFeature = obj as IFeature;
                    IPolyline pPolyLine = pFeature.Shape as IPolyline;
                    double ftLength = pPolyLine.Length;
//Place the length value in to the Pfeature respective field
                    pFeature.set_Value(pFeature.Fields.FindField(“ShapeFieldName”), ftLength);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                if (pCursor != null)
                {
//Use the Marshalling Method to release the Cursoer from the Memory
                    Marshal.ReleaseComObject(pCursor); 
                }
            }           
        }
//get_Enabled is a required Method for the Implemented Interface
        public bool get_Enabled(IObjectClass,pObjectClass, mmEditEvent eEvent)
        {
            return true;
        }

        
    }
}

Now Compile the Code and Execute.
Note:Set the Startup Project for Debugging as ArcCatalog.exe in the Project Properties.

Go to Arc-Catalog , Right Click on your ArcFM feature and Select ArcFm Properties Mangaer

Select the Object Tab.It will display the various event from the ArcFm for the Particular Object.
Assign your Auto Updaters to the various event you want to call.

Do the edit in the feature through ArcMap editor.This will trigger your Updaters.






Wednesday, 24 December 2014

ArcGIS Python Mapping Module


Arc Python to interact with Arc-map

What is ArcPy Mapping and Why is it actually used for :

Arcpy.mapping was built for the professional GIS analyst (as well as for developers). Traditionally, the scenarios listed above had to be done using ArcObjects and it often proved to be a very difficult programming environment to learn for the average GIS professional. Arcpy.mapping is a courser-grained object model, meaning that the functions are designed in a way that a single arcpy.mapping function can replace many lines of ArcObjects code. The following is a very simple example of how arcpy.mapping can be used to reference an existing map document and export it to a PDF document with only two lines of code.

To explore the Overall Arcpy mapping Module use the following PDF:

Arcpy Python Mapping Module


Code for Getting the reference to the MXD :

YourMXD= arcpy.mapping.MapDocument("path to the MXD")

To export the above MXD to PDF using arcpy:

arcpy.mapping.ExportToPdf(YourMXD,"your pdf file")



Get Reference to the Current Arcmap
Pointer to a MXD present on the Disk


Map Layout Document in the Arc map
Layout View of the Map Document

Arcpy.mapping is not a replacement for ArcObjects but rather an alternative for the different scenarios it supports. ArcObjects is still necessary for finer-grain development and application customization, whereas arcpy.mapping is intended for automating the contents of existing map documents and layer files.



Creating Geodatabases using Arcpy or Model builder

Creating Geo-databases in Arc Map

What is a Geodatabase:
  • A geodatabase is the common data storage and management framework for all the ArcGIS Products. It combines Geo (spatial data) with Database (data repository) to create a central data repository for all the spatial data storage and management in your ArcGIS platform.
  • It can be leveraged in desktop, server, or mobile environments and allows you to store GIS data in a central location for easy access and management.
The geodatabase offers you the ability to
  • Store a rich collection of spatial data in a centralized location.
  • Apply sophisticated rules and relationships to the data.
  • Define advanced geospatial relational models (e.g., topologies, networks).
  • Maintain integrity of spatial data with a consistent, accurate database.
  • Work within a multiuser access and editing environment.
  • Integrate spatial data with other IT databases.
  • Easily scale your storage solution.
  • Support custom features and behavior.
  • Leverage your spatial data to its full potential.
Arc-map geodatabase can be created using various way:
  1. Manually creating through Arc-Catalog
  2. Using the Model workflow to create it Programmatic-ally
  3. Using the Python integrated to Create Geodatabase Programmatic
  1. Model for Creating Feature Class
Model to create Geodatabase in ArcGIS
Set the workspace and OutputFC as the Model parameter

AddField will add a column to the newly created Feature class and can be populated with the user defined values

The Search, Insert or Update cursor can be used to manipulate the values present in the new Feature class

For achieving the above functionality it is advised to write a python code using the arcpy library.

To know more detailed step by step information about the creating a feature class in the Geodatabase
Click here - Create Geodatabase Feature Class - PDF




Arcpy Improvements in 10.1

Arc Python in ArcGIS 10.1

  1. Site package that adds ArcGIS functionality to Python
  2. Access to rich suite of geoprocessing tools
  3. Functions, classes and modules
  4. Helper functions like ListFeatureClasses, Describe
  5. Classes that can be used to create complex objects like Spatial Reference, Field Map
  6. Modules that provide specialized functionality like Mapping,SpatialAnalyst, NetworkAnalyst, DataAccess

Complete Introduction to Python concepts for beginners is available here

Python
ArcGIS + Python = ArcPython

For more info and advance Concepts use the folowing references: 

resources.ArcGIS.com
arcpy.wordpress.com
GIS Stack Exchange, Stack Overflow
Python References,Python Scripting for ArcGIS
GIS Tutorial for Python Scripting by Allen (Esri Press)
Learning Python by Lutz - The Python Standard Library
python.org
http://www.esri.com/training

Exporting the feature class to CSV Format


Exporting Geodatabase toComma Separated Value Format

Let start creating an python addin for converting the feature class in your geodatabase to CSV format.So that everyone can understand your feature class and its values.
  • If you are very new to python addin then go through- How to start with python addin 
  • The input feature class and output csv file path are hard coded in the sample program
  • For dynamic conversion get the path of the files through a variable and pass it as a parameter to the defined functions
Comma Seperated values
CSV Fromat



def ex_fc_to_csv(fc, out_csv):
    """
    Export all vertex in a line or poly feature class to a csv with OID
   
    example

        import geom_snippets
        geom_snippets.ex_fc_to_csv(r"c:\proj\fc1.shp", r"c:\proj\fc1.csv")

    output csv looks like this

        1,56019.99998067904,69118.00001450378
        1,56159.99998080942,69026.0000144181
        1,56359.999980995686,68913.00001431286
        2,34985.00002508866,68936.00001433428
        2,35178.000025268404,68805.00001421227

    """
    import csv
    import json

    with open(out_csv, 'w') as csvfile:
        csvwriter = csv.writer(csvfile, delimiter=',', lineterminator='\n')

        with arcpy.da.SearchCursor(fc,
                                   field_names=("OID@","SHAPE@JSON")) as cursor:
            for row in cursor:
                geom = json.loads(row[1])
                for path in geom['paths']:
                    for pt in path:
                        csvwriter.writerow([row[0]] + pt)

Friday, 12 December 2014

How to create a simple python add-in tool for ArcGIS Desktop

How to create a simple python add-in for ArcGIS Desktop


TOOL USED:  Python Add-in Assistant

WORKING OF THE TOOL:
Creating a Simple python add-in assistant for ArcGIS Desktop to add a Fishnet table to the ArcMap using the python
Type of Python Add-in: Tool Type
Function: At the end of drawing a rectangle on the ArcMap a fishnet with specified rows and columns should appear on the Screen
A python add-in tool is very similar to a button. But, a tool requires user to interact with the map application based on that interaction some business logic will get executed. The Zoom In tool Description: Zoom In in ArcMap will be a great example, when the user draws a rectangle on the ArcMap ,then the map will be redrawn with that rectangle as an extent.
Below steps will help you to create both Toolbox as well as a Tool on it

PROCEDURE:
Steps to Create a Toolbar for your Tool:
1.     To create your own toolbar. Open the Add-n assistant and Go to Add-in Contents tab and give the information about the add-in which you are going to create.
Note: A tool can reside on a Toolbar but cannot sits on a Menu
2.     Click the Add-In Contents tab and begin declaring your add-in customizations. A tool can reside on a toolbar but not on a menu. See creating an add-in toolbar for more detailed procedure.
3.     To Create the tool on your new Toolbar
Right-click the new toolbar and choose New Tool on the right click Menu.
Python addin assistant window

At once you have finished giving out the information and details about the add-in. Click on Save button at the bottom of the wizard. All the necessary files and folders will get created within the working folder of your add-in assistant.
Now it is the time to work on the main code. Go to the python script located on the install folder and open it using your Python idle. Code will appear as shown below with the class name same as your button name.
Note: Do not change the button name as it is directly linked with the button and registered in the your Config.xml file

 
Onclick() methof of the addin button class
The Onclick () method shown on idle will get executed on when the user click on the tool . But I our case the fishnet should get created whenever the user draw the tool is selected and draw an rectangle on the Map. So to do that OnRectangle () method of the python add-in will comes in to Picture. Replace on click method with OnRectangle () method as shown below:


Fishnet content added to On Rectangle method


·         The code will check for any preexistence of fishnet on the memory using the Exist() Method and deletes if anyone is already there using the Delete_Management() function.
·         CreateFishnet_management is the core function which is going to do the actual work after supply all the necessary parameters to it
·         Refresh the active view to redraw the Map and return the path of the fishnet to the calling function.







How to check for condition in Geoprocessing Service or Model Builder

How to check for if/else conditions in Geoprocessing Service


TOOL USED:  
Arc python and Script tool
Python script will be deployed in the ARC Toolbox to create the Conversion Tool 

WORKING OF THE TOOL:
Script tool is created in the ArcMap and the required input & Output Parameter are set. The script tool source is set to the custom python code present in an Python file(.py)
Out motive is to use check for the count of a features in an feature class and performing an conditional Execution

PROCEDURE:
  • Open ArcMap 10.0+ 
  • Create your own Geometric Network or Open your Existing Geometric Network
  • Add your Geometric network to the Table of contents in the ArcMap as Shown Below


·         Create a new Model in your myToolBox .Right Click on MyToolBox > New > Model.Following window will appear on the Screen 







  •    Add your desired feature class to the Model. (Right Click on any empty space and select ADD DATA  and select your feature class in the object browser)
  • ·         Add Get Count and Calculate value Model from the System Toolbox Connect the model as shown below 






  • ·         Now open calculate value Model and in the Expression Textbox call the function Calculate(%RowCount%)
  • ·         Here %RowCount% will act as an Inline Variable and Compiler automatically replace the %RowCount% with the value of the rowcount field
  • ·         At the Code block defined the function Calculate as

def calculate(row):
if row>0:
return true
else:
return false
  • ·         Make the return Data type as Boolean
  • ·         The output Boolean can be set as a precondition for any model. So that the Model  get executes only when the output of calculate value is true






How to create Graphical User Interface in Arcpy

To Show GUI in your Script tool of your ArcMap



Python consist of  huge number of GUI frameworks (or toolkits) available for it, from TkInter to a number of other cross-platform solutions.

In your case we going to use the default TkInter Module to access the windows form from the python script tool.
TkInter is being proposed as the most interactive and easy to program module in Python GUI framework

1. Create a new Script tool in the Arcmap's ArcCatalog window in your desired location
2. Copy the below codes in to a notepad file and save it as python .py extension
3.Go to the script tool and Right Click > Properties > Parameter
4.Browse to your newly created python code as the source file to execute
5.All is well.Start GUI python from TkInter. Happy Programming




from Tkinter import *
import datetime
from array import *



root = Tk()
logo = PhotoImage(file="Image.Gif")
w2 = Label(root,
           image=logo).grid(row=0,column=1)
explanation = """Team Geo Zoner"""
w2 = Label(root, 
          compound = CENTER,
           fg="Red",
           bg="black",
           font="Times 55 bold",
          text=explanation)
w2.grid(row=0,column=0)

p=str(datetime.datetime.now().isoformat())
texter="Your Heading Goes Here"+str(p);
w3 = Label(root, 
          compound = CENTER,
           fg="Green",
           font="Times 20 bold",
          text=texter)
w3.grid(row=1,column=0)

Parameters = ['Number of Inputs','Number of Ouputs','Number of Processing Parameters','Number of Intermediate data']

r = 2
i=1
for c in Parameters:
    Label(text=c, relief=RIDGE,width=25).grid(row=r,column=0)
    Entry(text="Value", relief=SUNKEN,width=10).grid(row=r,column=1)
    r = r + 1
    i = i + 1

root.title("GISSTUDY")
root.mainloop()

Saturday, 6 December 2014

Addin Setting flow direction in Geometric Network

Addin source code for setup flow direction   



1.Create an c# object with establish flow as a function

2.Call this function from the addin on click method by passing the application reference and the type of flow direction you wish to set to your network

To know more about geometric network setting flow direction setting flow direction


source code for setup flow direction
Setting Flow Direction through ArcObjects Code


public static void EstablishFlow(Globals.GNFlowDirection flowDirection, IApplication app)
        {
            IProgressDialog2 progressDialogs= default(IProgressDialog2);
            IProgressDialogFactory progressDialogFactorys = null;
            IEditor editing = null;
         
            IMouseCursor appCursor = null;
            INetworkAnalysisExt netExt = null;
            UID pUID = null;
         
            List<IGeometricNetwork> geonetworklist= null;
            ITrackCancel trackCancel = null;
            Int32 int32_hWnd;
            IStepProgressor stepProgressorobj= null;
            IMxDocument mxdoc = null;
   IEditLayers eLayers = null;
   IMap pMap = null;
            try
            {




                int calcCount = 0;

                //Get editing

                editing = Globals.geteditor(ref app);

                if (editing.EditState != esriEditState.esriStateEditing)
                {
                    MessageBox.Show(Teamgeofunctions.Localizer.GetString("MustBEditg"), Teamgeofunctions.Localizer.GetString("GeoNetToolsLbl_2"));
                    return;
                }

                eLayers = editing as IEditLayers;

                //Change mouse cursor to wait - automatically changes back (ArcGIS Desktop only)
                appCursor = new MouseCursorClass();
                appCursor.SetCursor(2);

                ESRI.ArcGIS.esriSystem.IStatusBar statusBar = app.StatusBar;
                statusBar.set_Message(0, Teamgeofunctions.Localizer.GetString("GeoNetToolsWait_1"));

                //Get NA Extension in order to update the current network with the first visible network
                pUID = new UIDClass();
                pUID.Value = "esriEditorExt.UtilityNetworkAnalysisExt";
                netExt = app.FindExtensionByCLSID(pUID) as INetworkAnalysisExt;

                //Get Visible geometric networks
                pMap = editing.Map;
                geonetworklist= Globals.GetGeometricNetworksCurrentlyVisible(ref pMap);


                if (gnList.Count > 0)
                {


                    //ProgressBar
                    progressDialogFactorys= new ProgressDialogFactoryClass();

                    // Create a CancelTracker
                    trackCancel = new CancelTrackerClass();

                    // Set the properties of the Step Progressor
                    int32_hWnd = app.hWnd;
                    stepProgressorobj= progressDialogFactory.Create(trackCancel, int32_hWnd);
                    stepProgressor.MinRange = 0;
                    stepProgressor.MaxRange = gnList.Count;
                    stepProgressor.StepValue = 1;
                    stepProgressor.Message = "";
                    stepProgressor.Hide();

                    // Create the ProgressDialog. This automatically displays the dialog
                    progressDialogs= (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast

                    // Set the properties of the ProgressDialog
                    progressDialog.CancelEnabled = false;
                    progressDialog.Description = Teamgeofunctions.Localizer.GetString("GeoNetToolsDesc_1");
                    progressDialog.Title = Teamgeofunctions.Localizer.GetString("GeoNetToolsTitle_1");
                    progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;

                    bool editStarted = false;
                    try
                    {// Create an edit operation enabling undo/redo
                        editing.StartOperation();
                        editStarted = true;
                    }
                    catch
                    {
                        editStarted = false;
                    }
                    IGeometricNetwork gn = null;
                    IEnumFeatureClass enumFC = null;
                    INetwork net = null;
                    IUtilityNetworkGEN unet = null;
                    IEnumNetEID edgeEIDs = null;
                    //IFeatureLayer fLayer = null;
                    try
                    {

                        for (int i = 0; i < gnList.Count; i++)
                        {

                            gn = gnList[i] as IGeometricNetwork;
                         
                            stepProgressor.Message = Teamgeofunctions.Localizer.GetString("GeoNetToolsProc_1");// +fLayer.Name;
                            //Establish flow using AncillaryRole values


                            if (flowDirection == Globals.GNFlowDirection.AncillaryRole)
                            {
                                enumFC = gn.get_ClassesByNetworkAncillaryRole(esriNetworkClassAncillaryRole.esriNCARSourceSink);
                                if (enumFC.Next() == null)
                                    MessageBox.Show(Teamgeofunctions.Localizer.GetString("GeoNetToolsError_1a") + gn.FeatureDataset.Name + Teamgeofunctions.Localizer.GetString("GeoNetToolsError_1b") + Environment.NewLine +
                                                    Teamgeofunctions.Localizer.GetString("GeoNetToolsError_1c"), Teamgeofunctions.Localizer.GetString("GeoNetToolsProc_2"));
                                else
                                {
                                    gn.EstablishFlowDirection();
                                    calcCount += 1;
                                }
                            }

                            //Establish flow direction based on digitized direction.
                            else
                            {
                                net = gn.Network;
                                unet = net as IUtilityNetworkGEN;
                                edgeEIDs = net.CreateNetBrowser(esriElementType.esriETEdge);
                                edgeEIDs.Reset(); int edgeEID;
                                for (long j = 0; j < edgeEIDs.Count; j++)
                                {
                                    edgeEID = edgeEIDs.Next();
                                    unet.SetFlowDirection(edgeEID, esriFlowDirection.esriFDWithFlow);
                                }
                                calcCount += 1;
                            }
                            stepProgressor.Step();

                        }
                    }

                    catch (Exception ex)
                    {
                        editing.AbortOperation();
                        MessageBox.Show(Teamgeofunctions.Localizer.GetString("GeoNetToolsProc_2") + "\n" + ex.Message, ex.Source);
                    }
                    finally
                    {
                        if (enumFC != null)
                            Marshal.ReleaseComObject(enumFC);

                        gn = null;
                        enumFC = null;
                        net = null;
                        unet = null;
                        edgeEIDs = null;
                        //fLayer = null;
                    }
                    if (editStarted)
                    {   // Stop the edit operation
                        if (flowDirection == Globals.GNFlowDirection.AncillaryRole)
                            editing.StopOperation(Teamgeofunctions.Localizer.GetString("GeoNetToolsProc_2"));
                        else
                            editing.StopOperation(Teamgeofunctions.Localizer.GetString("GeoNetToolsProc_3"));
                    }
                    object Missing = Type.Missing;
                    mxdoc = app.Document as IMxDocument;
                    mxdoc.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, Missing, mxdoc.ActiveView.Extent);

           
            }
            catch (Exception ex)
            {
       
                return;


            }
            finally
            {
                // delete the references to cleanup the memory
                if (progressDialogs!= null)
                    progressDialog.HideDialog();
                progressDialogs= null;
                progressDialogFactorys= null;
                editing = null;
                eLayers = null;
                appCursor = null;
                netExt = null;
                pUID = null;
                pMap = null;
                geonetworklist= null;
                trackCancel = null;

                stepProgressorobj= null;
                mxdoc = null;
            }

Wednesday, 26 November 2014

Custom Geoprocessing Tool


Arcobjects Geoprocessing Procedure:



1. Create a geoprocessor object and set its properties.
2. Set the appropriate values for the tool’s parameters.
3. Execute a tool using the geoprocessor object’s Execute() method.

In order to create a geoprocessor object, the IGeoProcessor2 interface can be used. This interface
is defined in the geoprocessing library of ArcObjects and is implemented by the GeoProcessor
CoClass.

IGeoProcessor2 gp = new GeoProcessorClass();
//add the result of geoprocessing as a new layer to Map
gp.AddOutputsToMap = true;
//if output of geoprocessing exists before the execution of tool
//it will be overwritten
gp.OverwriteOutput = true;

Assume that you want to create Thiessen polygons for the cities FeatureClass to create proximal
zones for all cities. The proximal zones represent full areas where any location inside the zone is
closer to its associated city than any other city. Based on the Create Thiessen Polygons reference
page, you have to provide at least an input point FeatureLayer and the path to the output
FeatureClass.
In order to create and set each parameter, the IVariantArray interface of the System library must
be used.

IVariantArray parameters = new VarArrayClass();

Each parameter has to be added to the IVariantArray interface in the exact order that is specified
on the tool’s reference page.

//in_features
parameters.Add(@"D:\DataFolder\fileGDB.gdb\cities");
//out_feature_class
parameters.Add(@"D:\DataFolder\fileGDB.gdb\citiesThiessen");
//fields_to_copy(Optional)
parameters.Add("ALL");

As it is illustrated on the Create Thiessen Polygons reference page, the third parameter is optional.
You can simply not add any value to IVariantArray or, as shown in the preceding code, you can
provide an appropriate value for the optional parameter. You can skip the optional parameter
using an empty string as input to IVariantArray’s Add() method. For example, look at the
reference page of the Buffer tool; you can see that three of the seven available parameters are
mandatory. The following code demonstrates how to skip the fourth parameter and specify the
fifth parameter:

//1-in_features
parameters.Add(@"D:\test.gdb\cities");
//2-out_feature_class
parameters.Add(@"D:\test.gdb\citiesBuffer");
//3-buffer_distance_or_field
parameters.Add("50 kilometers");
//4-line_side(Optional)
parameters.Add("");
//5-line_end_type(Optional)
parameters.Add("ROUND");
//6 &7 there is no need to provide empty string
//for the rest of parameters since you don't want to set them
After setting all the required parameters, all you need to run a tool is to call the Execute() method
of the geoprocessor object. The Execute() method solicits the name of the tool and its parameters.

gp.Execute("CreateThiessenPolygons_analysis", parameters, null);
The following code shows the complete code for this example. In order to run the code, you need to
add references to the Geoprocessing and System libraries of ArcObjects:
IGeoProcessor2 gp = new GeoProcessorClass();
//add the result of geoprocessing as a new layer to Map
gp.AddOutputsToMap = true;
//if output of geoprocessing exists before the execution of tool
//it will be overwritten
gp.OverwriteOutput = true;
IVariantArray parameters = new VarArrayClass();
//in_features
parameters.Add(@"D:\DataFolder\fileGDB.gdb\cities");
//out_feature_class
parameters.Add(@"D:\DataFolder\fileGDB.gdb\citiesThiessen");
//fields_to_copy(Optional)
parameters.Add("ALL");
//or parameters.Add("");
gp.Execute("CreateThiessenPolygons_analysis", parameters, null);


The Geoprocessing library of ArcObjects is accessible through the ESRI.ArcGIS.Geoprocessing
namespace. This library contains a few hundred types which can be used to run and manage tools
and GIS workfl ows. You learned earlier in this section that IGeoProcessor2 is the main interface of
this library and the easiest way to run a geoprocessing tool is to call its Execute() method.
However, using IGeoProcessor2 is not the only approach to run a geoprocessing tool or model.
There are some managed assemblies created by Esri to performing geoprocessing in a managed
way. A managed way means there is a native .NET assembly (the Geoprocessor assembly) that is
a wrapper for some types in the Geoprocessing library of ArcObjects, and there are other .NET
assemblies for each system toolbox.
These native .NET assemblies provide an even easier way to run a system tool. In general, the
procedure for running a tool using the Geoprocessor-managed assembly is the same as running a tool

Thursday, 20 November 2014

Feature Count using Model Builder

Software Required:
  1. ArcMap 10.2 or more


Procedure:
  • Open ArcMap 10.2+ 
  • Goto Window > Show ArcCatalog
  • ArcCatalog Right Click on the Default GeoDatabase and Create New Feature Class.Give a name for the new feature class and Click Finish
  • Add a New Model to the Database New > Model Tool after creating a New ToolBox
  • Add Get Count and Calculate Value to the New Model
  • Set GetCount Ouput Value as  the Precondition for Calculate Value
  • Add the following procedure for the Calculate value Model






Expression

CountMe(%RowCount%)

Code Block
def CountMe(n):
  if n > 0: 
     return "true" 
  else: 
     return "false"



The Output of the Calculate Value Model is Boolean(True or False).Setting the output value of Calculate Value as the Precondition for the desired Model will make it model to run only when the output is True