The ArcToolbox

The ArcToolbox of ArcGIS 9.3

The ArcToolbox is a collection of tools provided by ESRI that achieve a number of geoprocessing operations. They are logically organized in themes based on the functionality, and are available to use without any customization. These operations can be very powerful and achieve great results. As you can see from the image on the right, there is a number of tools available to you to use. Depending on the extensions you have installed, you will see some different results, but the Geocoding Tools we mentioned above are available with any kind of license. To use any of these geoprocessing tools, you simply double-click on its name, and a window will pop up asking you for the required inputs and outputs. Pay attention to all the options available to you, and make use of the help button to clarify what the operation does, and how it is achieved.

The Model Builder

The Model Builder Window

The Model Builder is a wonderful program written by ESRI that allows you to graphically define geoprocessing operations. Using a simple tool, a user can drag and drop operations and data on a canvas, and connect them with directional arrows (signifying direction of data). On the example on the right, we follow the Address Geocoding operation. There are three data inputs for the operation, including an address locator, address fields to be used, and finally the input table with the addresses. There is one more data element in the picture, the output feature, on the far right. Note that all data are represented by ovals. The operation, which is in the middle, receives data from all the arrows pointing to it, and returns data to the arrow pointing outwards. Notice that the operation is in a rectangular box rather than an oval, to distinguish it.

The Command Line

The Command Line Window

The command line window is one more way to achieve geoprocessing when one is using ArcGIS. The window simply allows one to type commands, an hit enter to execute them. Some users are more familiar with this interface, and like the speed of which you can type operations. Typing a few letters in the top box will give you a list of all commands starting with those letters. Pressing space will bring the tooltip shown in the top of the image on your right. As you can see, it tells you what the tool expects to run. In this case, it expects an input table (in_table), an address locator (address_locator), the address fields (in_address_fields) and where to save the output (output_feature). Optionally, you can set the out_relation_type (notice the curly braces this time).

Python Scripting

Python Scripting Geocoding

The perhaps most complex way to perform geocoding is done through Python scripting. The example on the right actually presents geoprocessing code. What happens when one uses Python Scripting to create geoprocessing operations is similar with the command line option talked about earlier, with some slight changes. Python scripting gives you the option to interact with the data deeper. What this means is that the user can now access an individual point by latitude and longitude. And since all vector spatial data are built from points, this means you have deep access to any spatial data using Python (to see more about Accessing Geometries using the Geoprocessor click here). Also, as Python is a general use scripting language, you can find reusable code by other users (in the form of modules) to achieve things like reading Excel files (click here for an overview).

And that is what geoprocessing is. Operations that work on spatial data. In the ArcGIS realm, that means either using ArcToolbox, the Model Builder, the Command Line interface or creating your own Python Scripts to achieve your desired results.

Related posts:

1. Understanding the Geoprocessor Programming Model part 1

import xlwt # Import the package
wbook = xlwt.Workbook() # Create a new workbook
sheet = wbook.add_sheet("Sample Sheet") # Create a sheet
data = "Sample data" # Something to write into the sheet
for rowx in range(5):
# Loop through the first five rows
for colx in range(5):
# Loop through the first five columns
# Write the data to rox, column
sheet.write(rowx, colx, data)
# Save our workbook on the harddrive
wbook.save("myFile.xls")

And that is all you need. You just created a brand new Excel file called myFile.xls within Python without the use of Excel itself. The file has the first 5 rows and columns filled out with the text “Sample data”. It is trivial then to change this so it can save any data you want with a little bit more of Python.

Related posts:

1. Manipulating Excel files using Python part 1: Reading Excel Files

Before continuing, let’s discuss the basic idea of Excel. This programs stores data in what is called a Workbook. Think of this as the file on your computer (the .xls). A Workbook can then have one or more Sheets, the little tabs on the bottom left corner usually. Within each Sheet, you can find an arrangement of Cells in a matrix form, which are referenced by Column Name and Row Number (so the top left cell is A1, the one directly to its right is A2, the one below is B2, etc. The image should help shed some light if you are not familiar with the concept of spreadsheets.

In order to read Excel sheets in Python without using any Microsoft Office code, we need to use the excellent xlrd packge by Lingfo. The basic workflow is as follows:

1. Open a workbook using book = xlrd.open_workbook(“filetoread.xls”)
2. Access a sheet in the workbook using sheet = book.sheet_by_index(0) to open the first sheet, or if you know the name, sheet = book.sheet_by_name(“Name of Sheet”)
3. Retrieve data using any of the multiple methods: cellValue =sheet.cell_value(rowx, colx), or to retrieve a whole column use colValues = sheet.col_values(colx, start_rowx=0, end_rowx=None) or the retrieve a whole row use rowValues = sheet.row_values(rowx, start_colx=0, end_colx=None)

The basic idea is very simple, and we can easily write a little Python script that will allow us to read Excel files without the need to use Excel itself. The following example will offer a preview of an Excel file’s first sheet using the first 5 rows and columns of a file.

import xlrd # Import the package
book = xlrd.open_workbook("sample.xls") # Open an .xls file
sheet = book.sheet_by_index(0) # Get the first sheet
for counter in range(5): # Loop for five times
# grab the current row
rowValues = sheet.row_values(counter,start_col=0, end_colx=4)
# Print the values of the row formatted to 10 characters wide
print "%-10s | %-10s | %-10s | %-10s | %-10s" % tuple(rowValues)
# Print row separator
print "-" *62

That is all there is to it. Quick, fast and no need for Excel whatsoever. Sample output is presented below:

Related posts:

1. Manipulating Excel files using Python part 2: Writing Excel Files