Geospatial Python

Create a Polygon Shapefile using Python

Morgan — Fri, 26 Feb 2010 02:33:08 +0000

I have been traveling for the last few weeks and did not update this site as much as I would have liked. In this script we will create the final feature class using Python, a polygon. As I posted previously all the shapes in ArcGIS are made up of points. Lines are just points that are connected by, wait for it..lines. Polygons are just enclosed areas defined by points. Here is a simple script that creates a triangle.

import arcgisscripting
gp = arcgisscripting.create()

try:
outFolder = r”C:\Temp”
outFile = “Polygon.shp”
gp.workspace = outFolder

# When creating a polygon the coordinates for the starting point must be the same as the coordinates for the ending point.

# This is because all polygons must close. So below there are three sets of X,Y coordinates but we will enter four points into the array. Despite the four points the resulting shape will be a triangle, again this is because the first and last points are the same.

# The first set of coordinates will be used for the starting and ending point.

StartandEndXcoord = -66.068999
StartandEndYcoord = 18.398997

PointOneXcoord = -64.779165
PointOneYcoord = 32.28903

PointTwoXcoord = -80.270216
PointTwoYcoord = 25.832124

sr = gp.CreateSpatialReference(“C:\Program Files\ArcGIS\Coordinates Systems\Geographic Coordinates Systems\World\WGS 1984.prj”, “#”, “#”, “#”, “#”, “#”)

gp.CreateFeatureClass (outFolder, outFile, “Polygon”, “#”,”#”,”#”, sr)
cur = gp.InsertCursor (outFile)
row = cur.NewRow()

PolygonArray = gp.CreateObject (“Array”)
pnt = gp.CreateObject (“Point”)

pnt.x = StartandEndXcoord
pnt.y = StartandEndYcoord
PolygonArray.add(pnt)

pnt.x = PointOneXcoord
pnt.y = PointOneYcoord
PolygonArray.add(pnt)

pnt.x = PointTwoXcoord
pnt.y = PointTwoYcoord
PolygonArray.add(pnt)

pnt.x = StartandEndXcoord
pnt.y = StartandEndYcoord
PolygonArray.add(pnt)

row.shape = PolygonArray
cur.InsertRow(row)

del row, cur

except:
gp.GetMessage(2)

Simple Script for Creating a Polyline Shapefile

Morgan — Thu, 04 Feb 2010 00:59:29 +0000

This example of basic python scripting shows how to create a line between two points. ESRI has a good Technical Article about how to create a line using python but theirs is a little more complex. Keeping in line with my goal of making things as simple as possible this script is the most basic form of creating a line. The code is very similar to my last post on how to create a point, that is because all the complex shapes in ArcGIS are really just points with connecting lines. The new object in this script is the Array. To keep this simple, you can think of an Array as a place to store the point coordinates before you draw a line connecting them. So as your script reads in a set of coordinates for a point you store them in an Array. Then once you have all the points that make up the line in the Array the script tells the geoprocesser to create the line connecting the points. This time I only added very simple comments, this is closer to what scripts you find on the internet would look like. I have also left off any error handling, this was to place the focus on the most basic parts go the script. Don’t worry it will be back next time.

import sys, string, os, arcgisscripting
gp = arcgisscripting.create()
gp.OverWriteOutput = True

# Set output folder and file name

outFolder = r”C:\Temp”
outFile = “SingleLine.shp”

# Set workspace
gp.workspace = outFolder

# Assign the x and y coordinates values to the starting variables

StartXcoord = -63.650997
StartYcoord = 44.679996

# Assign the x and y coordinates values to the ending variables
EndXcoord = -74.011221
EndYcoord = 40.663962

# Assign the spatial reference
sr = gp.CreateSpatialReference (“C:\Program Files\ArcGIS\Coordinate Systems\Geographic Coordinate Systems\World\WGS 1984.prj”, “#”, “#”, “#”, “#”, “#”)

# Create the Feature class to which the line will be added
gp.CreateFeatureClass (outFolder, outFile, “POLYLINE”, “#”, “#”, “#”, sr)

# Create the insert cursor and point it at the file just created
cur = gp.InsertCursor (outFile)

# Move cursor to point at the first empty row in the file

row = cur.NewRow()

# Create the Array object to store the points for the line
LineArray = gp.CreateObject(“Array”)

# Create the Point object to store the coordinates for the points

pnt = gp.CreateObject (“Point”)

# Set the x & y start coordinates
pnt.x = StartXcoord
pnt.y = StartYcoord

# Add the point to the Array

LineArray.add(pnt)

# Set the x & y end coordinates
pnt.x = EndXcoord
pnt.y = EndYcoord

# Again add the point to the Array

LineArray.add(pnt)

# Set the shape property of the first row in the shapefile to the values held in the LineArray. Because we had to defined the shapefile type (polyline) when using CreateFeatureClass the shape property of file knows that it should create lines between each point in the array.

row.shape = LineArray

# Insert the row into the output shapefile
cur.InsertRow(row)

# Clean up
del row, cur

Creating a Point Shapefile with Python

Morgan — Sun, 24 Jan 2010 05:27:00 +0000

Ok, for the first example of basic geoprocessing code created in python, I have created a small script that creates a point shapefile from and x and y coordinate. This code is intended to be very basic, and therefore can’t be attached to a toolbox without some small changes. I plan on posting about how to add code to a toolbox later on.
I am making the assumption that you have at least some basic understanding of how ArcGIS and python interact. I will not be explaining all of the details of objects and methods, but I will be providing examples of basic scripts. I have added a lot of comments, far more than I do when scripting for my self, to try to make things as clear as possible. So here is how to create a point shapefile from Python.

########################################################
##Name: Create Single Point
## Source Name: CreateSinglePoint.py
## Version: ArcGIS 9.2
## Author: Morgan
## Usage: CreateSinglePoint ,
## Required Arguments: Folder to save the shapefile into and the name of the shapefile to create.
## Optional Arguments: None
## Description: This script is a very basic demonstration of how to turn a single x,y ##coordinate pare into a point shapefile
##The coordinates supplied are in the WGS_84 coordinate system. This script is not ##setup to be imported directly into an ArcGIS toolbox.
## Date January 18th 2010
########################################################

# Import required modules
import sys, os, string, arcgisscripting

# Create the Geoprocesser
gp = arcgisscripting.create()

# By Setting OverWriteOutput to “True” the script will predictably, over write any files with the same name in the same directory
gp.OverWriteOutput = True

# The Try statement is use to handle errors. It allows you to decide what happens when your script encounters a problem and wants to crash. If an error is found within the try indentation you script will jump to the Except statement and run what ever code this there before ending.

try:
# Set local variables. Here is where we set where the file will be saved and what the new point file should be named. Setting the workspace is a good habit to get into because as your scripts get more complex it will help simplify file management.

outFolder = r”C:\Temp”
outFile = “SinglePoint.shp”
gp.Workspace = outFolder

# The x and y coordinates are also local variables. In this scrip they are set in the script. In the future I will post on how to read the values out of a text file.

xCoord = -73.01543847
yCoord = 45.34837726

# It is very important that every file you create has a spatial reference. Every place I have ever used ArcGIS has always used the default install location for storing the Coordinate definition files. That is why I am setting the spatial reference using an absolute path.

sr = gp.CreateSpatialReference (“C:\Program Files\ArcGIS\Coordinate Systems\Geographic Coordinate Systems\World\WGS 1984.prj”)

# The create feature class tool comes from the Data Management toolbox. This is what I will use to create an empty shapefile. It is into this shapefile that we will add our point.

gp.CreateFeatureClass_managment (outFolder, outFile, “Point”, “#”, “#”, “#”, sr)

# Now all we need to do is insert the point into our new shapefile. To do that we need a cursor. ESRI defines a cursor as a “data access object”. What that means is that in order to interact with the properties of a file, like adding new features, changing or adding records to a attribute table, you need to create a cursor. There are three types of cursors, Insert, Update, and Search. When you want to create points, Lines (two or more connected points), or Polygons (Several points enclosing an area) you need a cursor. Also you can see that in python all the common file types are made up of points. You can think of the cursor as an arrow point to a record in the attribute table. If you want to insert data into the table, and create a feature, you need to create a new row. This is done with the .NewRow() method. Next you need to create a point object and set it’s x, y values to the location where you want it to sit. In our case this is the values held in the xCoord, and yCoord variables. The last thing you need to do is to insert the new row into the file. Here is the code to do all that.

cur = gp.InsertCurosr(outFile)
row = cur.NewRow()
pnt = gp.CreateObject(“Point”)
pnt.x = xCoord
pnt.y = yCoord

row.shape = pnt
cur.InsertRow(row)

# Clean up. You always want to delete the cursor and row objects when you are done using them. This will release the memory the computer has set aside to hold these data.

del cur, row
Except:
Print “Error! There is something wrong with your script.”

Welcome, One and All

Morgan — Wed, 30 Dec 2009 04:11:22 +0000

This site will be up and running very soon. I hope to bring you some basic python scripts to use in ESRI’s ArcGIS (did you get that google). When I started to teach myself how to write geoprocessing scripts, I kept wishing there was a site with examples of how to preform some basic tasks. I wanted to know how to create a point or line, and how to loop though a group of files in a folder. The original impetus for learning to script, was to be able to batch process, something that was difficult to do in model builder. I hope you will find this site informative and that I can help you lean to script in python.