Python and ArcMap

1. Python and ArcMap Examples from ‘Help” of ArcMap

2. Benefits of Python • Easy to read and use syntax • Large library • Supports raising and catching exceptions • Supports objects oriented programming

3. Python and ArcMap • Python is used to automate geoprocessing tools such as the following which are in the ArcToolbox: • Analysis, cartography, conversion, data management, editing, geocoding • Python also allows more advanced processing such as looping through records in a database and reading and writing them • It also allows manipulating layers in a map • It allows creating and manipulating geometries (point, line, polygon)

4. arcpy • arcpy was introduced to ArcGIS in its 10th version • It is downloaded with your ArcGIS! • You can find it under your ArcGIS folder, e.g. at: Program Files > ArcGIS >Desktop10.1 • You just need an editor such as PythonWin, IDLE, ArcMap Python window, or even Calculator field to access arcpy • If after typing import arcpy in front of the Python prompt you do not get an error, then you have the arcpy! >>> import arcpy # Got no error? Then you can slither!

5. arcpyOpens Modules • arcpy can open many modules • Module: is a self contained collection of functions and classes that does something • These modules include: • Data access module (arcpy.da) • Mapping module (arcpy.mapping) • Geostatistical Analyst module (arcpy.ga) • ArcGIS Spatial Analyst extension module (arcpy.sa) • ArcGIS Network Analyst extension module (arcpy.na)

6. … import arcpy# imports ArcGIS geoprocessingfunctionality import arcpy.mapping# imports only the mapping module import os # imports Python’s core operating system import sys # variables/functions used or maintained by the interpreter # import env from arcpy and set the workspace environment from arcpy import env # ability to control ArcGIS environment env.workspace = “C:\data” from arcpy.management import *# Content imported into namespace. Can use content without prefix

7. Python Window • Interacts with ArcGIS • Accesses arcpy and its functionalities • Accesses tools, and environments • It is intelligent, completes code

8. Running in ArcMap • Open Python Window in version 10 by clicking on its icon in the menu bar • We can write Python code while a map is open, for example to set a buffer around a road at different distances • It will automatically create new layer for these buffers (e.g., at different distances)

9. Python Window

10. ArcObjects • ArcGIS is made of many types of ArcObjects • These include: features, layers, maps, map documents, applications • Even tables, their fields, and rows are ArcObjects • Each of these ArcObjects has its own properties and methods, through which it interacts with other ArcObjects • ArcObjects can be manipulated with arcpy

11. Properties and Methods • Manipulating ArcObjects requires knowing their properties • Properties/Methods of two ArcObjects are shown below: Map Feature Class Properties layer count Name Spatial reference Map scale Extent Methods Add layer Clear Selection Select feature Properties Shape type Spatial reference Extent Methods Create feature Remove feature

12. Statements • A statement is a task that does not return a value, e.g., print, import, and if statements: import arcpy print “bye; have a gneiss rock!” # import functionality from ArcGIS Spatial Analyst import arcpy.sa from arcpy.sa import * arcpy.CheckOutExtension (“Spatial”) # Check the Spatial Analyst License import arcy.mapping as map • If statement checks if a condition is true or false • For loop is another statement, loops through a list for fc in fclist: print fc

13. Environments • We set the environment for tools to use them • This includes setting the current workspace, output spatial reference, extent, raster analysis setting (cell size, mask) arcpy.env.workspace arcpy.env.outputCoordinateSystem arcpy.env.extent arcpy.env.cellSize arcpy.evn.mask

14. Example # add buffer around the road feature class with given distances import arcpy arcpy.env.workspace = ”C:\data\City.gdb”#sets the workspace fc = “Roads” #variable feature class distanceList = [“100 meters”, “200 meters”, 400 meters”]# distances # loops through each distance in the distanceList # takes the first distance and puts it in variable dist, and repeats it 3 times for dist in distanceList: outName = fc+” _”+ dist arcpy.Buffer_analysis (fc, outName, dist) # outputs the feature class, its output name_distance # breaks out of the loop print “Buffering completed!”

15. Another example • Clipping a road feature in ArcMap • Click on the Python Window icon in ArcMap • Clear the window from old code, if necessary • Type the following code: # clip Roads feature class from the Mineral_Spring city polygon, # output the clipped feature class into RoadsClip arcpy.clip_analysis (“Roads”, “Mineral_Springs”, “RoadsClip”) # Run it # You can see in ArcMap the new added RoadsClip feature class # which was created and automatically added to the table of content

16. Tool messages • When we execute a tool, there might be three types of messages: • Informative messages • Warning messages • Error messages try: # start try block arcpy.Buffer (“C:/ws/roads.shp”, “C:/outws/roads10.shp”, 10) # print the tool messages except arcpy.ExecuteError: print arcpy.GetMessages (2) # any other error Except Exception as e: print e.message

17. Functions • Functions perform useful tasks, such as: • Accessing geoprocessing tool messages (GetMessages) • Listing data for batch processing, e.g.: • ListFeatureClasses, ListFields, plus nine other list functions • Retrieving a dataset’s properties (Describe) import arcpy # Set the workspace for ListFeatureClasses function arcpy.env.workspace = “c:/test” # For each feature class, create a scratch name and clip for fc in arcpy.ListFeatureClasses (): outName = arcpy.CreateScratchName (“clipped_” + fc, “”, “featureclass”, arcpy.env.workspace) arcpy.Clip_analysis(fc, “boundary”, outName)

18. Dealing with Functions/Methods • Assigning a value to a property: # object.property = value for example: env.workspace = “C:/Temp” • Return the value of a property: # object.property for example: print “The workspace is “ + env.workspace • Use a method: # object.method (arg1, arg2, …) e.g., put a buffer for a road: arcpy.Buffer_analysis (“c:/input/roads.tif’, “c:/output.gdb/buffer_output, 100)

19. The Describe function • Takes some feature class, table, raster image (e.g., properties: type, number of bands, resolution), database, workspace, and describe it • e.g., we can find how many fields a table has, what is their type and name • Returns an object with dynamic properties • Allows script to determine properties of data, e.g.: • Data type (shapefile, coverage, network dataset, etc) • Shape type (point, polygon, line) • Spatial reference • Extent of features • List of fields

20. # Returns the shape type (point, line, polygon) of a feature class desc= arcpy.Describe (featureClass)# or d = arcpy.Describe (“c:/base.gdb/rivers”) # branches based on input’s shapeType property: if d.shapeType == “polygon”: arcpy.FeatureToLine_management (inFC, outFC) else: arcpy.CopyFeatures_management (inFC, outFC) # print selected feature class properties print “shapeType”. desc.shapeType print “the first field’s name”, desc.fields[0].name print “the first field’s type”, desc.fields[0].type

21. List functions • Get a list of feature classes, tables, rasters, etc. • Process data using a loop through the list # returns a list of feature classes, tables # for examples all the tables in a geodatabase, or fields in a table fcList = arcpy.ListFeatureClasses() # copy shapefiles to a file geodatabase one item at a time # loop through the list of shape files using copy management tool for fc in fcList: arcpy.Copy_management (fc, “d/base/output.gdb” + os.set + fc.rstrip(“ .shp’))

22. Cursor function • Cursor allows access of a collection of records. It allows: • Iterating over the set of rows in a table • Inserting new row in a table • Accessing a geometry • Cursors read and write values while looping through a cursor, one record at a time. This can allow us to edit a table by adding or deleting records • There are three types of cursors: • Search • Insert • Update

23. Example # Create the search cursor for the roads feature class whose type is # not equal to 4 cur = arcpy.SearchCursor(“roads”. ‘”TYPE” <> 4’) # iterate through the rows in the cursor, one record at a time # print road name and the CFCC code for row in cur: print “Name: “ + row.NAME + “ “ + “CFCC code: “ + row.CFCC

24. Example 2 import arcpy # Print road name and type for row in arcpy.SearchCursor (“D:/data.gdb/roads”): print “Road name:” row.roadName print “Road type:” row.getValue (“roadType”) del row

25. Cursor allows iteration for row in arcpy.SearchCursor (myTable) print row.GetValue (“Rank”)

26. Insert Cursor • Can create a new geometry cur = arcpy.InsertCursor (fc) # Create array and point objects: ptList = [arcpy.Point (358331, 5273193), arcpy.Point (358337, 5272830)] lineArray = arcpy.Array(ptList) # Create a new row for the feature class feat = cur.newRow () # set the geometry of the new feature to the array points feat.Shape = lineArray # Insert the feature Cur.insertRow (feat) # Delet objects del cur, feat

27. Geometry objects • We can create, delete, move, and reshape features # Create a geometry object and put it in the variable g g = arcpy.Geometry () # Run the Copy Features tool. set the output to the geometry object # Return a list of geometry objects (lines, streets) geometryList = arcpy/CopyFeatures_management (“c:/data/streets.shp”, g) # Loop through each geometry, totaling the lengths of the streets # for geometry in geometryList: length += geometry.length# Note: x +=1 means x=x+1 print “Total length: %f” % length

28. Mapping module • arcpy.mapping • Is used to open and manipulate existing map documents (.mxd) and layer files (.lyr) • It is used to query and alter the contents • Find a layer with data source X and replace with Y • Updata a layer’s symbology across many MSDs • Generate a report listing document information • Data sources, broken layers, spatial reference, etc. • Can print, export, or save the modified document • Allows adding, removing, and rotating data frames, and adding and removing layers • We can manipulate properties of map documents and layers • See next slide for an example

29. Manipulate map documents # Set data frame properties and export to a TIFF import arcpy # Find the Project.mxd map document mxd = arcpy.mapping.MapDocument (”c:\Project\Project.mxd”) # make a list of all the data frames in it; iterate through the frames for df in arcpy.mapping.ListDataFrames (mxd): df.rotation = 0 # rotate the map df.scale = 24000 # set the scale outFile = ”c:\Project\Output\\” + df.name + “.tif” arcpy.mapping.ExportToTIFF (mxd, outFile, df) del mxd

30. Example 2 # Modify map document properties, save changes to a layer file, and save changes to the map document import arcpy mxd = arcpy.mapping.MapDocument (“input.mxd”) df = arcpy.mapping.ListDataFrames (mxd) df.scale= 24000 df.rotation = 2.7 for lyr in arcpy.mapping.ListLayers(mxd): if lyr.name == “Landuse”: lyr.visible = True lyr.showLabels = True lyr.saveACopy(“output.lyr”) mxd.save() del mxd

31. Manipulating Layers • We can change properties of a layer, such as its: • name, source data, visibility (make it on or off), transparency, label, definition query, display order, etc. import arcpy # open a file on our hard drive lyrFile = arcpy.mapping.Layer (”C:\Project\Date\Streets.lyr”) # we are going to change its name, from streets to highways for lyr in arcpy.mapping.ListLayers(lyrFile): if lyr.name.lower() == “highways”: # turn its label on lyr.showLabels = True lyr.saveACopy (r”C:\Project\Data\StreetsWithLabels.lyr”) # now the changed layer is saved as different layer del lyrFile

32. Adding a Python script as a tool • We can add a script as a tool to a toolbox • These are called script tools • They become a new tool with all the properties of a tool, e.g., • It will return messages, access to all environment settings, and automatically add the output to our map (to the table of contents in ArcMap) • Can easily be shared, e.g., email it to other users • they can double click it to run it) • Tools automatically create dialog boxes (created for us by ArcGIS) • We can even add the tool into the toolbar and menus

33. ArcMap • Access a snapping tool in the toolbox • Need to go to ArcCatalog (run from ArcMap) to make a snap tool • Make a directory MyToolbox • Right click it, and then > add Script • Add script dialog opens • We can have the script ready in the Python Window which needs to be added to ArcMap • Give it a name and label (e.g., Snap and Snap), > next • Write the script file name (snap.py)