All code samples in Python are part of the course Geog 173 at UCLA. For the final project on building ArcToolbox using Python, visit Oil and Gas Seep Risk Assessment.
Tips to copy Python code with syntax highlights. Download and install Notepad++ and do the following:
#################################################################
#
--------------------------------------------------------------------
Tips to copy Python code with syntax highlights. Download and install Notepad++ and do the following:
- Open Notepad++. Paste your code in the window
- Select the programming language from the language menu
- Select the text to copy
- There are a couple of tips to follow here. Make sure that the import statement is the first statement on the code in Notepad++, and then further ensure that you have scrolled down the code to its end. Then Right click and select Plugin commands -> Copy Text with Syntax
- Paste it into MS Word. Now select all text and copy from MS Word and paste it in this post, and you get Python code with formatting as shown below.
#################################################################
import math
# Lab 1: Python Basics
# Date: Jan 20, 2012
# Geog 173, GIS
Development and Programming
# University of
California, Los Angeles
#
----------------------------------------------------------------
# 1. Mathematical
Calculation
#
----------------------------------------------------------------
# This section of code
will demonstrate the use of variables in mathemical computation
# Adding numbers
#print value of pi
print math.pi
k = 81
ksqrt = math.sqrt(k)
print "Square root of 81
is: " + str(ksqrt)
#add number
a = 1
b = 2
c = a + b
s = str(c) #convert
number to string
# append string
variables and print the result
msg = "Sum of 1 and 2 is: "
print msg + s
# Divide numbers
a = 8.0
b = 2.0
c = a/b
s = str(c) #convert number to string
# append string
variables and print the result
msg = "Divide 8 by 2 is: "
print msg + s
# Multiply numbers
width = 10.0 #width of rectangular room
length = 20.0 #length of rectangular room
area = width * length
s = str(area) #convert number to string
# append string
variables and print the result
msg = "Area of room of size 10x20 is: "
print msg + s
#Add complex numbers
a = 2.0 + 4.0j #2.0 is real component, 4.0 is imaginary component of complex
number a
b = 3.5 + 5.6j
c = a + b
print "Real component of
complex number is: " + str(c.real)
print "Imaginary component
of complex number is: " + str(c.imag)
#
----------------------------------------------------------------
# 2. String handling
#
----------------------------------------------------------------
#append or concatenate
strings
a = "Department of Geography"
b = "University of California, Los Angeles"
c = a + b
print c
#append and use newline
character
a = "Department of Geography \n"
b = "University of California, Los Angeles"
c = a + b
print c
#Find part of string
a = "Department of Geography"
i = a.find("Geography")
print "Starting location
of substring Geography is: "
+
str(i) #convert integer i into
string
#
----------------------------------------------------------------
# 3. String and list
indexing
# ----------------------------------------------------------------
#3a: String indexing
#Find part of string
(substring)
a = "Department of Geography"
b = a[0:10]
print "Substring is :
" + b #will print Department
b = a[14:]
print "Substring is :
" + b #will print Geography
c = a[0:10] + a[14:]
print "Substring is :
" + c
#Use negative location
in a string
a = "Department of Geography"
b = a[-9:] #last 9 characters, and will print Geography
print "Last 9 characters
are: " + b
#Length of string
a = "Department of Geography"
i = len(a)
print "Length of string
Department of Geography is: "
+
str(i)
#3b: List indexing
la = ['potato','tomato','onion']
print la[0] #will print the value of
item at 0 location - potato
print la[0:2] #will print tomato
print la[0:]
#replace tomato with
oranges
la[1] = "oranges"
print la[1]
print la[0:]
#remove onion
la.remove("onion")
print la[0:]
#Insert apple at the
front
la.insert(0,"apple")
print la[0:]
#
----------------------------------------------------------------
# 4. Decision making
#
----------------------------------------------------------------
#If statement
#if the age of kids is
less than 5 yrs, give them icecream
#otherwise, let them eat
pizza
age = 10
if age < 5:
print "This kid is less
than 5 yrs of age. Give this kid an icecream!"
else:
print "This kid is more
than 5 yrs of age. Give this kid a pizza slice"
#use elif
age = 7
if age < 5:
print "This kid is less
than 5 yrs of age. Give this kid an icecream!"
elif age == 5:
print "This kid is 5 yrs
of age. Give this kid an option because this is a party for 5 yr old!"
else:
print "This kid is more
than 5 yrs of age. Give this kid some pasta"
#
----------------------------------------------------------------
# 5. Iteration control
#
----------------------------------------------------------------
#While statement
#we make a decision to
increase the value of i by 1, and then print
#it while it is less
than 10
i = 1 #initialize variable
while i < 10: #code within indentation is part of while loop
print "value of i is:
" + str(i)
i = i + 1
print "we are out of while
loop"
#for loop
la = ['potato','tomato','onion']
for x in la:
print "for loop item is:
" + x
#
----------------------------------------------------------------
# 6. File handling
#
----------------------------------------------------------------
#a. create a file
#b. write to file and
save it
#c. read from file
# Create a file object:
# in "write"
mode
filename = r"C:\temp\pythonsample.txt"
file = open(filename,'w')
# Write all the lines at
once:
i=0
while i < 10: #code within indentation is part of while loop
#print
"value of i is: " + str(i)
file.write("value of i is: "
+
str(i) + "\n")
i = i + 1
file.close()
#Read from file
filename = r"C:\temp\pythonsample.txt"
file = open(filename,'r')
print file.readlines()
file.close()
#################################################################
import os
import arcpy
# Lab 2: Python works
# Date: Jan 20, 2012
# Geog 173, GIS
Development and Programming
# University of
California, Los Angeles
#
----------------------------------------------------------------
#Task 1
#
----------------------------------------------------------------
# This section of code
will demonstrate stand alone python scripts that excute fucntions like Read
from files.
fileList = list() #create an empty list
path = r'C:\Anshu\UCLA\Winter 2012\Geog 173\week 3\Lab2_G173_Data'
listing = os.listdir(path)
for infile in listing:
fileList.append(infile)
print "current file is:
" + infile
#
----------------------------------------------------------------
#Task 2
#
----------------------------------------------------------------
# This section of code
will demonstrate function like identify the number and names of all the
shapefiles in the list.
#print items in list
shapefile_Number = 0
shapefile_Name_List = list() #create an empty list
for item in fileList:
f = str(item)
fileExtension = f[-3:]
#print
"fileextension : " + fileExtension
if fileExtension == "shp":
shapefile_Name_List.append(f)
shapefile_Number = shapefile_Number + 1
print "Shapefile in
directory is: " + item
print "Shapefile number
is: " + str(shapefile_Number)
#
----------------------------------------------------------------
#Task 3
#
----------------------------------------------------------------
# This section
demonstrates Arcpy scripts to execute geoprocessing such as buffer, selection,
etc
# If the output
shapefile already exists on the disk, make sure to delete it. Other
#ArcGIS will generate an
error.
try:
arcpy.env.workspace = "C:\\Anshu\\UCLA\\Winter
2012\\Geog 173\\week 3\\Lab2_G173_Data"
#Buffer:
buffer all cities by 10 km
#
Local variables:
NA_Cities = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\week
3\\Lab2_G173_Data\\NA_Cities.shp"
NA_Cities_Buffer_shp = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\week
3\\Lab2_G173_Data\\NA_Cities_Buffer.shp"
#
Process: Buffer
arcpy.Buffer_analysis(NA_Cities, NA_Cities_Buffer_shp, "10000 Meters", "FULL", "ROUND", "NONE", "")
print "Buffer is
complete"
#Select:
select all cities in USA
#
Local variables:
USCities_shp = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\week
3\\Lab2_G173_Data\\USCities.shp"
#
Process: Select
arcpy.Select_analysis(NA_Cities, USCities_shp, "\"FIPS_CNTRY\"
= 'US'")
print "Select is complete"
except Exception, e:
#
If an error occurred, print line number and error message
import traceback, sys
tb = sys.exc_info()[2]
print "Line %i" % tb.tb_lineno
print e.message
print "Lab2 testing is
complete!"
#################################################################
# Lab 3: Geoprocessing tool using Python
# Date: Feb 5, 2012
# Geog 173, GIS Development and Programming
# University of California, Los Angeles
# CitiesInLake.py
# Usage: CitiesInLake <Lake_Buffers_shp> <NA_Cities>
<Cities_Selected_shp> <Distance__value_or_field_>
<summary_dbf>
# Description: Find cities that are exposed to risk of flooding in lakes
in North America
#
--------------------------------------------------------------------
# Import arcpy module
import arcpy
# Define inputs and outputs - Script arguments
NA_Big_Lakes = arcpy.GetParameterAsText(0)
Distance__value_or_field_ = arcpy.GetParameterAsText(1)
Lake_Buffers_shp = arcpy.GetParameterAsText(2)
NA_Cities = arcpy.GetParameterAsText(3)
Cities_Selected_shp = arcpy.GetParameterAsText(4)
summary_dbf = arcpy.GetParameterAsText(5)
# Buffer lakes to a distance provided by user on the dialog. This will
produce an output buffered lake layer
arcpy.Buffer_analysis(NA_Big_Lakes, Lake_Buffers_shp, Distance__value_or_field_, "FULL", "ROUND", "NONE", "")
# Intersect buffered lake layer with cities layer to select cities that
are within lakes. These are exposed to flodding risks.
arcpy.Intersect_analysis("'C:\\Anshu\\UCLA\\Winter 2012\\Geog
173\\Lab3\\Lake_Buffers.shp' #;NA_Cities #",
Cities_Selected_shp, "ALL", "", "INPUT")
# Prepare Summary Statistics of selected cities layer to indicate number
of cities affected and their total population in table.
arcpy.Statistics_analysis(Cities_Selected_shp, summary_dbf, "CNTRY_NAME
COUNT;Population SUM", "")
#################################################################
#################################################################
#################################################################
import os
import arcpy
import sys
# Lab 4: Manipulating
tables using cursor objects
# Date: Feb 12, 2012
# Geog 173, GIS
Development and Programming
# University of
California, Los Angeles
#
----------------------------------------------------------------
# Step 1
#
----------------------------------------------------------------
# Setup workspace
arcpy.env.workspace = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab4"
# Get NA_cities
shapefile
NA_Cities = "'C:\\Anshu\\UCLA\\Winter 2012\\Geog
173\\Lab4\\NA_Cities.shp'"
# Create output table
# Set local variables
outPath = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab4"
tableName = "NACities12"
template = "'C:\\Anshu\\UCLA\\Winter 2012\\Geog
173\\Lab4\\NA_Cities.shp'"
config_keyword = ""
# Execute CreateTable
arcpy.CreateTable_management(outPath, tableName, template, config_keyword)
#Delete fields that are
not needed
#arcpy.DeleteField_management(tableName,
"FID;GMI_ADMIN;FIPS_CNTRY;STATUS;POP_RANK;PORT_ID")
#arcpy.CreateTable_management("C:\\Anshu\\UCLA\\Winter
2012\\Geog 173\\Lab4", "NACities11",
"'C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab4\\NA_Cities.shp'",
"")
#
----------------------------------------------------------------
# Step 2
#
----------------------------------------------------------------
# Create a search cursor
from the NA_Cities shapefile
arcpy.env.workspace = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab4"
cur = arcpy.SearchCursor('C:\\Anshu\\UCLA\\Winter
2012\\Geog 173\\Lab4\\NA_Cities.shp')
#
----------------------------------------------------------------
# Step 2
#
----------------------------------------------------------------
# Create an insert
cursor on output table
curTable = arcpy.InsertCursor('NACities12')
# Cycle through each
feature and check them for condition
# POP_CLASS - this field
has following classes, it does not have numeric population values
#1,000,000 to 5,000,000
#100,000 to 250,000
#250,000 to 500,000
#5,000,000 and greater
#50,000 to 100,000
#500,000 to 1,000,000
#Less than 50,000
# CNTRY_NAME = United
States, Mexico, Canada
for row in cur:
country = row.CNTRY_NAME
popClass = row.POP_CLASS
#US
Cities with population >= 8 million
if (country == "United States") and (popClass == "5,000,000 and greater"):
rowTable = curTable.newRow()
rowTable.CNTRY_NAME = row.CNTRY_NAME
rowTable.POP_CLASS = row.POP_CLASS
rowTable.CITY_NAME = row.CITY_NAME
rowTable.ADMIN_NAME = row.ADMIN_NAME
curTable.insertRow(rowTable)
#Mexican
Cities with population >= 8 million
if (country == "Mexico") and (popClass == "5,000,000 and greater"):
rowTable = curTable.newRow()
rowTable.CNTRY_NAME = row.CNTRY_NAME
rowTable.POP_CLASS = row.POP_CLASS
rowTable.CITY_NAME = row.CITY_NAME
rowTable.ADMIN_NAME = row.ADMIN_NAME
curTable.insertRow(rowTable)
#Canadian
Cities with population >= 3 million
if (country == "Canada") and (popClass == "1,000,000 to 5,000,000"):
rowTable = curTable.newRow()
rowTable.CNTRY_NAME = row.CNTRY_NAME
rowTable.POP_CLASS = row.POP_CLASS
rowTable.CITY_NAME = row.CITY_NAME
rowTable.ADMIN_NAME = row.ADMIN_NAME
curTable.insertRow(rowTable)
# Delete objects from
memory
del cur, curTable, row, rowTable
#Delete fields that are
not needed
arcpy.DeleteField_management(tableName, "FID;GMI_ADMIN;FIPS_CNTRY;STATUS;POP_RANK;PORT_ID")
print "Lab4 code test is
complete!"
#################################################################
import arcpy
import math
#
---------------------------------------------------------------------------
# Lab 5: Geometry using
cursor objects
# Date: Feb 25, 2012
# Geog 173, GIS
Development and Programming
# University of
California, Los Angeles
# Cities near Lake.py
# Description: Find
nearest city to lakes in North America
#
---------------------------------------------------------------------------
# The code starts by
cycling through each lake. It loops through each vertex
#of a lake feature. It
then calculates distance to each city from the vertex.
#It then selects the smallest
distance, and this becomes the minimum distance,
#and the city becomes
the nearest city at this iteration of vertex. This process
#continues for each
vertex until we run out it, and the smallest distance is
#selected as the
required distance.
# ---------------------------------------------------------------------------
#The tool offers an
alternative option also to calculate the distance of city
#to the centroid of
lake. This is the bonus question.
#
---------------------------------------------------------------------------
# Import arcpy module
# Define inputs and
outputs - Script arguments
arcpy.env.workspace = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab5"
Lakes = arcpy.GetParameterAsText(0)
Cities = arcpy.GetParameterAsText(1)
New_Lakes = arcpy.GetParameterAsText(2)
Center_Lakes = arcpy.GetParameterAsText(3)
##Python arguments
## Arguments =
NA_Big_Lakes.shp NA_Cities.shp New_Lakes.shp
Center_Lakes.shp
##Lakes=
'NA_Big_Lakes.shp'
##Cities =
'NA_Cities.shp'
##New_Lakes =
'New_Lakes.shp'
##Center_Lakes =
'Center_Lakes.shp'
# Copy lakes to new lake
layer
arcpy.Copy_management(Lakes, New_Lakes, "FeatureClass")
#Add fields to new lakes
layer: CNTRY_NAME, ADMIN_NAME, POP_CLASS, DISTANCE, XY
arcpy.AddField_management(New_Lakes, "CITY_NAME", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(New_Lakes, "CNTRY_NAME", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(New_Lakes, "ADMIN_NAME", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(New_Lakes, "POP_CLASS", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(New_Lakes, "DISTANCE", "FLOAT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(New_Lakes, "XY", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Identify the geometry
field
desc = arcpy.Describe(New_Lakes)
shapeName = desc.ShapeFieldName
# Identify the geometry
field in Cities shapefile
desc = arcpy.Describe(Cities)
shapefieldnameCity = desc.ShapeFieldName
#Get lake cursor
inrows = arcpy.SearchCursor(New_Lakes)
# Loop through each
row/feature
lakecount = 0
for row in inrows:
lakecount = lakecount + 1
CITY_NAME = ""
CNTRY_NAME = ""
ADMIN_NAME = ""
POP_CLASS = ""
DISTANCE = 0
XY = ""
#print
"shapeName" , shapeName
#
Create the geometry object
feature = row.getValue(shapeName)
print "Lake Feature ID:
" ,str(row.FID) , "
Area: " , str(row.Area_km2)
partnum = 0
distMin = -1 #initial value
#
Count the total number of points in the current multipart feature
partcount = feature.partCount
#print
'num parts: ', partcount
while partnum < partcount:
part = feature.getPart(partnum)
pnt = part.next()
#print
'outer while'
pntcount = 0
#
Enter while loop for each vertex
while pnt:
#get
lake vertex
xLake = pnt.X
yLake = pnt.Y
#Calculate
distance from this lake vertex to city
#Get
a search cursor on Cities shapefile
cityCursor = arcpy.SearchCursor(Cities)
iCity = 0
for rowCity in cityCursor:
iCity = iCity + 1
featCity = rowCity.getValue(shapefieldnameCity)
pntCity = featCity.getPart()
# Print x,y coordinates of current point
xCity = pntCity.X
yCity = pntCity.Y
#distance
x = xLake - xCity
y = yLake - yCity
dist = math.sqrt((x*x) + (y*y))
if distMin == -1:
distMin = dist #will be executed only the first to initialize distMin with first
vertex
CITY_NAME = rowCity.CITY_NAME
CNTRY_NAME = rowCity.CNTRY_NAME
ADMIN_NAME = rowCity.ADMIN_NAME
POP_CLASS = rowCity.POP_CLASS
DISTANCE = distMin
XY = str(xCity) + "," + str(yCity)
elif dist < distMin:
distMin = dist
CITY_NAME = rowCity.CITY_NAME
CNTRY_NAME = rowCity.CNTRY_NAME
ADMIN_NAME = rowCity.ADMIN_NAME
POP_CLASS = rowCity.POP_CLASS
DISTANCE = distMin
XY = str(xCity) + "," + str(yCity)
## if pntcount%100 == 0:
## print CITY_NAME,
CNTRY_NAME, ADMIN_NAME, POP_CLASS, DISTANCE, XY
del cityCursor #Release
memory
#print
CITY_NAME, CNTRY_NAME, ADMIN_NAME, POP_CLASS, DISTANCE, XY
#arcpy.AddMessage("Lake
FID: " + str(row.FID) + ": " + CITY_NAME + " " +
CNTRY_NAME + " " + ADMIN_NAME
+ " " + POP_CLASS + "
" + str(DISTANCE) + " " + XY)
#print
str(pnt.X), str(pnt.Y)
#print
"partcount: " + str(partcount)
pntcount += 1
pnt = part.next()
#
If pnt is null, either the part is finished or there is an
# interior ring
if pnt is None:
pnt = part.next()
if pnt:
arcpy.AddMessage("Interior
Ring:")
print CITY_NAME, CNTRY_NAME, ADMIN_NAME, POP_CLASS, DISTANCE, XY
arcpy.AddMessage("Lake FID: " + str(row.FID) + ": " + CITY_NAME + " " + CNTRY_NAME + " " + ADMIN_NAME + " " + POP_CLASS + " " + str(DISTANCE) + " " + XY)
partnum += 1
#print
'pntcount: ', pntcount
#while
ends
print "Assign values to
lake row"
#Assign
attribute to lake features
fid = str(row.FID)
updateRows = arcpy.UpdateCursor(New_Lakes,"FID=" + str(fid) )
for updateRow in updateRows:
updateRow.CITY_NAME = CITY_NAME
updateRow.ADMIN_NAME = ADMIN_NAME
updateRow.POP_CLASS = POP_CLASS
updateRow.DISTANCE = DISTANCE
updateRow.XY = XY
#Update
row
updateRows.updateRow(updateRow)
#Release
memory
del updateRow
del updateRows
print "City attributes
updated: ", CITY_NAME, ADMIN_NAME, POP_CLASS, DISTANCE, XY
#Exit
for loop on rows of lakes
## if lakecount == 1: #for testing only
## print "Breaking from for
loop"
## break
#Loop for lake features
end here - for row in lakeCursor:
del row, inrows
print "It is done!"
#
----------------------------Alternative method to calculate distance
---------
#This method uses
centroid of polygon to calculate distance
#
------------------------------------------------------------------------------
#If user did not enter
value for lake centroid layer, exit here. We are done!
##if
len(str(Center_Lakes) == 0:
## sys.exit(0)
# Copy new lakes to new
layer for centroid based calculation
arcpy.Copy_management(New_Lakes, Center_Lakes, "FeatureClass")
#Get cursor
inrows = arcpy.SearchCursor(Center_Lakes)
#Calculate distance to
centroid
# Loop through each
row/feature
lakecount = 0
for row in inrows:
lakecount = lakecount + 1
CITY_NAME = ""
CNTRY_NAME = ""
ADMIN_NAME = ""
POP_CLASS = ""
DISTANCE = 0
XY = ""
#print
"shapeName" , shapeName
#
Create the geometry object
feature = row.getValue(shapeName)
#Get
centroid
centerPoint = feature.trueCentroid
print "Lake Feature ID:
" ,str(row.FID) , "
Area: " , str(row.Area_km2)
distMin = -1 #initial value
#get
lake vertex
xLake = centerPoint.X
yLake = centerPoint.Y
print "Centroid ", xLake, yLake
#Calculate
distance from this lake vertex to city
#Get
a search cursor on Cities shapefile
distMin = -1
cityCursor = arcpy.SearchCursor(Cities)
iCity = 0
for rowCity in cityCursor:
iCity = iCity + 1
featCity = rowCity.getValue(shapefieldnameCity)
pntCity = featCity.getPart()
#
Print x,y coordinates of current point
xCity = pntCity.X
yCity = pntCity.Y
#distance
x = xLake - xCity
y = yLake - yCity
dist = math.sqrt((x*x) + (y*y))
if distMin == -1:
distMin = dist #will be executed only the first to initialize distMin with first
vertex
CITY_NAME = rowCity.CITY_NAME
CNTRY_NAME = rowCity.CNTRY_NAME
ADMIN_NAME = rowCity.ADMIN_NAME
POP_CLASS = rowCity.POP_CLASS
DISTANCE = distMin
XY = str(xCity) + "," + str(yCity)
elif dist < distMin:
distMin = dist
CITY_NAME = rowCity.CITY_NAME
CNTRY_NAME = rowCity.CNTRY_NAME
ADMIN_NAME = rowCity.ADMIN_NAME
POP_CLASS = rowCity.POP_CLASS
DISTANCE = distMin
XY = str(xCity) + "," + str(yCity)
#print
"Iteration for Lake FID: ", str(row.FID), CITY_NAME, ADMIN_NAME,
POP_CLASS, DISTANCE, XY
#arcpy.AddMessage("Lake
FID: " + str(row.FID) + ": " + CITY_NAME + " " +
CNTRY_NAME + " " + ADMIN_NAME
+ " " + POP_CLASS + " "
+ str(DISTANCE) + " " + XY)
del cityCursor #Release memory
arcpy.AddMessage("Lake FID: "
+
str(row.FID) + ": " + CITY_NAME + " " + CNTRY_NAME + " " + ADMIN_NAME + " " + POP_CLASS + " " + str(DISTANCE) + " " + XY)
#print
"City attributes updated: ", str(row.FID), CITY_NAME, ADMIN_NAME,
POP_CLASS, DISTANCE, XY
#Assign
attribute to lake features
fid = str(row.FID)
updateRows = arcpy.UpdateCursor(Center_Lakes,"FID=" + str(fid) )
for updateRow in updateRows:
updateRow.CITY_NAME = CITY_NAME
updateRow.ADMIN_NAME = ADMIN_NAME
updateRow.POP_CLASS = POP_CLASS
updateRow.DISTANCE = DISTANCE
updateRow.XY = XY
#Update
row
updateRows.updateRow(updateRow)
#Release
memory
del updateRow
del updateRows
#Exit
for loop on rows of lakes
## if lakecount == 1: #for testing only
## print "Breaking from for loop"
## break
#Loop for lake features
end here - for row in lakeCursor:
del row, inrows
print "It is done!"
#################################################################
import arcpy
import math
import os
#
---------------------------------------------------------------------------
# Lab 5: Geometry using
cursor objects
# Date: March 3, 2012
# Geog 173, GIS
Development and Programming
# University of
California, Los Angeles
# Kiahore_A_Lab6.py
# Description: create a
map book of lakes in North America
#
---------------------------------------------------------------------------
## Import arcpy module
import arcpy
import math
import os
# Define inputs and
outputs - Script arguments
arcpy.env.workspace = "C:\\Anshu\\UCLA\\Winter 2012\\Geog 173\\Lab5"
Lakes = arcpy.GetParameterAsText(0)
Cities = arcpy.GetParameterAsText(1)
NA = arcpy.GetParameterAsText(2)
##Python arguments
## Arguments =
NA_Big_Lakes.shp NA_Cities.shp New_Lakes.shp
Center_Lakes.shp
Lakes= 'NA_Big_Lakes.shp'
NA = 'North_America.shp'
Cities = 'NA_Cities.shp'
##New_Lakes =
'New_Lakes.shp'
##Center_Lakes = 'Center_Lakes.shp'
# Identify the geometry
field
desc = arcpy.Describe(Lakes)
shapeName = desc.ShapeFieldName
# Identify the geometry
field in Cities shapefile
##desc =
arcpy.Describe(Cities)
##shapefieldnameCity =
desc.ShapeFieldName
#Get lake cursor
inrows = arcpy.SearchCursor(Lakes)
# Set up variables for
output path and PDF file name
outDir = r"C:\Anshu\UCLA\Winter 2012\Geog 173\Lab6"
finalMapPDF_filename = outDir + r"\NA_Big_Lake_Mapbook.pdf"
# Remove existing
multi-page PDF if it exists
if os.path.exists(outDir + r"\TempMapPages.pdf"):
os.remove(outDir + r"\TempMapPages.pdf")
# Check whether the
mapbook PDF exists. If it does, delete it.
if os.path.exists(finalMapPDF_filename):
os.remove(finalMapPDF_filename)
# Create map book PDF
finalMapPDF = arcpy.mapping.PDFDocumentCreate(finalMapPDF_filename)
# Create MapDocument
object pointing to specified mxd
mxd = arcpy.mapping.MapDocument(outDir + r"\Lakes.mxd")
# Get dataframe
df = arcpy.mapping.ListDataFrames(mxd, "Layers")[0]
#
----------------------------------------------------------------------------#
# Start appending pages.
Title page first.
#
----------------------------------------------------------------------------#
# Find text element with
value "test", and replace it with other value
mapText = "A Map Book for North American Large Lakes " + '\n\r' + "Kishore, A.,
Geog173, Geography, UCLA" + '\n\r' + " Lake number:
18" + '\n\r' + " Total area: 362117
km2" + '\n\r' + " Mean area: 20118
km2"
print mapText
for elm in arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT"):
if elm.text == "test":
elm.text = mapText
arcpy.RefreshTOC()
arcpy.RefreshActiveView()
#df.extent =
feature.extent
arcpy.mapping.ExportToPDF(mxd, outDir + r"\TempMapPages.pdf")
# Append multi-page PDF
to finalMapPDF
finalMapPDF.appendPages(outDir + r"\TempMapPages.pdf")
#initialize text value,
so it can be reused in next iteration
for elm in arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT"):
if elm.text == mapText:
elm.text = "test"
#
----------------------------------------------------------------------------#
# Loop through each lake
#
----------------------------------------------------------------------------#
# Loop through each
row/feature
lakecount = 0
for row in inrows:
lakecount = lakecount + 1
CITY_NAME = ""
CNTRY_NAME = ""
ADMIN_NAME = ""
POP_CLASS = ""
DISTANCE = 0
XY = ""
#print
"shapeName" , shapeName
#
Create the geometry object
feature = row.getValue(shapeName)
mapText = "Lake FID: "
+
str(row.FID) + ", Area (km2): "
+
str(row.Area_km2)
print mapText
#
Find text element with value "test", and replace it with other value
for elm in arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT"):
if elm.text == "test":
elm.text = mapText
arcpy.RefreshTOC()
arcpy.RefreshActiveView()
df.extent = feature.extent
arcpy.mapping.ExportToPDF(mxd, outDir + r"\TempMapPages.pdf")
#
Append multi-page PDF to finalMapPDF
finalMapPDF.appendPages(outDir + r"\TempMapPages.pdf")
#initialize
text value, so it can be reused in next iteration
for elm in arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT"):
if elm.text == mapText:
elm.text = "test"
# Set up properties for
Adobe Reader and save PDF.
finalMapPDF.updateDocProperties(pdf_open_view = "USE_THUMBS",
pdf_layout = "SINGLE_PAGE")
finalMapPDF.saveAndClose()
# Done. Clean up and let
user know the process has finished.
del row, inrows
del mxd, finalMapPDF
print "Map book for lakes
in North America is complete!"
No comments:
Post a Comment