class ReportWriter():
"Writes the report files"
def __init__(self, reportFormat, reportName=''):
supportedFormats = ["CSV", "SHP", "KMZ"]
if reportFormat not in supportedFormats:
raise Exception("Report format not supported: " + reportFormat)
self.reportFormat = reportFormat
if ('' != reportName):
self.overWriteOutput = True
self.reportName = reportName
else:
self.overWriteOutput = False
self.reportName = 'report'
def write(self, fObject, doZip=False):
folder = arcpy.env.scratchFolder
name = self.reportName
if "CSV" == self.reportFormat:
fname = self._writeCSV(fObject, name, folder, doZip)
elif "SHP" == self.reportFormat:
fname = self._writeSHP(fObject, name, folder)
elif "KMZ" == self.reportFormat:
fname = self._writeKMZ(fObject, name, folder)
else:
raise Exception("Report format not implemented")
return fname
def _writeCSV(self, fObject, name, folder, doZip=False):
if self.overWriteOutput:
filePath = os.path.join(folder, name + '.csv')
if arcpy.Exists(filePath): arcpy.Delete_management(filePath)
else:
filePath = arcpy.CreateScratchName(name, ".csv", "", folder)
print filePath
try:
if isinstance(fObject, FieldObject):
with open(filePath, 'wb') as csvfile:
fieldwriter = csv.writer(csvfile, delimiter=',', \
quoting=csv.QUOTE_MINIMAL)
fieldwriter.writerow(fObject.getLabelsList())
for i in range(fObject.getNumberOfFeatures()):
featureList = fObject.getFeatureList(i, doFormat=True)
fieldwriter.writerow(featureList)
else:
fs = fObject.getFeatureSet()
rows = arcpy.SearchCursor(fs)
fieldnames = [f.name for f in arcpy.ListFields(fs)]
allRows = []
for row in rows:
rowlist = []
for field in fieldnames:
rowlist.append(row.getValue(field))
allRows.append(rowlist)
with open(filePath, 'wb') as csvfile:
fieldwriter = csv.writer(csvfile, delimiter=',', \
quoting=csv.QUOTE_MINIMAL)
fieldwriter.writerow(fieldnames)
for row in allRows:
fieldwriter.writerow(row)
except Exception, e:
raise e
#raise Exception("Could not write to CSV file")
if doZip:
try:
if self.overWriteOutput:
zipPath = os.path.join(folder, name + '.zip')
if arcpy.Exists(zipPath): arcpy.Delete_management(zipPath)
else:
zipPath = arcpy.CreateScratchName(name, ".zip", "", folder)
z = Zipper()
z.zipFiles([filePath], zipPath)
filePath = zipPath
except:
raise Exception("Could not zip CSV file")
return filePath
meanRaster = CreateConstantRaster(mean, "FLOAT", descR.MeanCellHeight,
descR.extent)
outRaster = (r - meanRaster) / stdvRaster
elif analysisType == "Stretch":
arcpy.AddMessage("Running Stretch Transformation ......")
maxVal = arcpy.GetRasterProperties_management(r, "MAXIMUM")
maxRaster = CreateConstantRaster(maxVal, "FLOAT", descR.MeanCellHeight,
descR.extent)
minVal = arcpy.GetRasterProperties_management(r, "MINIMUM")
minRaster = CreateConstantRaster(minVal, "FLOAT", descR.MeanCellHeight,
descR.extent)
inputMax = arcpy.GetParameterAsText(2)
if not (arcpy.Exists(inputMax)):
inputMax = 1
inputMaxRaster = CreateConstantRaster(inputMax, "FLOAT",
descR.MeanCellHeight,
descR.extent)
inputMin = arcpy.GetParameterAsText(3)
if not (arcpy.Exists(inputMin)):
inputMin = 0
inputMinRaster = CreateConstantRaster(inputMin, "FLOAT",
descR.MeanCellHeight,
descR.extent)
outRaster = (r - minRaster) * (inputMaxRaster - inputMinRaster) / (
maxRaster - minRaster) + inputMinRaster
elif analysisType == "Normalize":
nodeID = row[1]
row[f + 2] = nodeDict[streamID][nodeID][field]
cursor.updateRow(row)
#enable garbage collection
gc.enable()
try:
print("Step 2: Measure Channel Width")
#keeping track of time
startTime = time.time()
# Check if the output exists
if not arcpy.Exists(nodes_fc):
arcpy.AddError("\nThis output does not exist: \n" +
"{0}\n".format(nodes_fc))
sys.exit("This output does not exist: \n" + "{0}\n".format(nodes_fc))
if overwrite_data is True:
env.overwriteOutput = True
else:
env.overwriteOutput = False
# Determine input spatial units
proj_nodes = arcpy.Describe(nodes_fc).spatialReference
proj_rb = arcpy.Describe(rb_fc).spatialReference
proj_lb = arcpy.Describe(lb_fc).spatialReference
# Check to make sure the rb_fc/lb_fc and input points are
def mainFunction(
downloadLink, updateMode, geodatabase, featureDataset
): # Get parameters from ArcGIS Desktop tool by seperating by comma e.g. (var1 is 1st parameter,var2 is 2nd parameter,var3 is 3rd parameter)
try:
# --------------------------------------- Start of code --------------------------------------- #
# Download the file from the link
file = urllib2.urlopen(downloadLink)
# Download in chunks
fileChunk = 16 * 1024
with open(os.path.join(arcpy.env.scratchFolder, "Data.zip"),
'wb') as output:
while True:
chunk = file.read(fileChunk)
if not chunk:
break
# Write chunk to output file
output.write(chunk)
output.close()
# Unzip the file to the scratch folder
arcpy.AddMessage("Extracting zip file...")
zip = zipfile.ZipFile(os.path.join(arcpy.env.scratchFolder,
"Data.zip"),
mode="r")
zip.extractall(arcpy.env.scratchFolder)
# Get the newest unzipped database from the scratch folder
database = max(glob.iglob(arcpy.env.scratchFolder + r"\*.gdb"),
key=os.path.getmtime)
# Assign the geodatabase workspace and load in the datasets to the lists
arcpy.env.workspace = database
featureclassList = arcpy.ListFeatureClasses()
tableList = arcpy.ListTables()
arcpy.AddMessage("Copying datasets...")
# Load the feature classes into the geodatabase if at least one is in the geodatabase provided
if (len(featureclassList) > 0):
# Loop through the feature classes
for eachFeatureclass in featureclassList:
# Create a Describe object from the dataset
describeDataset = arcpy.Describe(eachFeatureclass)
# If feature dataset provided, add that to path
if featureDataset:
outputDataset = os.path.join(
geodatabase + "\\" + featureDataset,
describeDataset.name)
else:
outputDataset = os.path.join(geodatabase,
describeDataset.name)
exportData = "true"
# If update mode is then copy, otherwise delete and appending records
if (updateMode == "New"):
# Copy feature class into geodatabase using the same dataset name
arcpy.CopyFeatures_management(eachFeatureclass,
outputDataset, "", "0", "0",
"0")
else:
# If dataset exists in geodatabase, delete features and load in new data
if arcpy.Exists(outputDataset):
arcpy.DeleteFeatures_management(outputDataset)
arcpy.Append_management(
os.path.join(arcpy.env.workspace,
eachFeatureclass), outputDataset,
"NO_TEST", "", "")
else:
exportData = "false"
# Log warning
arcpy.AddWarning(
"Warning: " + outputDataset +
" does not exist and won't be updated")
# Logging
if (enableLogging == "true"):
logger.warning(
outputDataset +
" does not exist and won't be updated")
if (exportData.lower() == "true"):
datasetRecordCount = arcpy.GetCount_management(
outputDataset)
arcpy.AddMessage(
str(outputDataset) + " record count - " +
str(datasetRecordCount) + "...")
# Logging
if (enableLogging == "true"):
logger.info(
str(outputDataset) + " record count - " +
str(datasetRecordCount) + "...")
if (len(tableList) > 0):
# Loop through of the tables
for eachTable in tableList:
# Create a Describe object from the dataset
describeDataset = arcpy.Describe(eachTable)
outputDataset = os.path.join(geodatabase, describeDataset.name)
exportData = "true"
# If update mode is then copy, otherwise delete and appending records
if (updateMode == "New"):
# Copy feature class into geodatabase using the same dataset name
arcpy.TableSelect_analysis(eachTable, outputDataset, "")
else:
# If dataset exists in geodatabase, delete features and load in new data
if arcpy.Exists(os.path.join(geodatabase, eachTable)):
arcpy.DeleteRows_management(
os.path.join(geodatabase, eachTable))
arcpy.Append_management(
os.path.join(arcpy.env.workspace, eachTable),
outputDataset, "NO_TEST", "", "")
else:
exportData = "false"
# Log warning
arcpy.AddWarning(
"Warning: " + outputDataset +
" does not exist and won't be updated")
# Logging
if (enableLogging == "true"):
logger.warning(
outputDataset +
" does not exist and won't be updated")
if (exportData.lower() == "true"):
datasetRecordCount = arcpy.GetCount_management(
outputDataset)
arcpy.AddMessage(
str(outputDataset) + " record count - " +
str(datasetRecordCount) + "...")
# Logging
if (enableLogging == "true"):
logger.info(
str(outputDataset) + " record count - " +
str(datasetRecordCount) + "...")
# --------------------------------------- End of code --------------------------------------- #
# If called from gp tool return the arcpy parameter
if __name__ == '__main__':
# Return the output if there is any
if output:
# If ArcGIS desktop installed
if (arcgisDesktop == "true"):
arcpy.SetParameterAsText(1, output)
# ArcGIS desktop not installed
else:
return output
# Otherwise return the result
else:
# Return the output if there is any
if output:
return output
# Logging
if (enableLogging == "true"):
# Log end of process
logger.info("Process ended.")
# Remove file handler and close log file
logMessage.flush()
logMessage.close()
logger.handlers = []
# If arcpy error
except arcpy.ExecuteError:
# Build and show the error message
errorMessage = arcpy.GetMessages(2)
printMessage(errorMessage, "error")
# Logging
if (enableLogging == "true"):
# Log error
logger.error(errorMessage)
# Log end of process
logger.info("Process ended.")
# Remove file handler and close log file
logMessage.flush()
logMessage.close()
logger.handlers = []
if (sendErrorEmail == "true"):
# Send email
sendEmail(errorMessage)
# If python error
except Exception as e:
errorMessage = ""
# Build and show the error message
# If many arguments
if (e.args):
for i in range(len(e.args)):
if (i == 0):
# Python version check
if sys.version_info[0] >= 3:
# Python 3.x
errorMessage = str(
e.args[i]).encode('utf-8').decode('utf-8')
else:
# Python 2.x
errorMessage = unicode(e.args[i]).encode('utf-8')
else:
# Python version check
if sys.version_info[0] >= 3:
# Python 3.x
errorMessage = errorMessage + " " + str(
e.args[i]).encode('utf-8').decode('utf-8')
else:
# Python 2.x
errorMessage = errorMessage + " " + unicode(
e.args[i]).encode('utf-8')
# Else just one argument
else:
errorMessage = e
printMessage(errorMessage, "error")
# Logging
if (enableLogging == "true"):
# Log error
logger.error(errorMessage)
# Log end of process
logger.info("Process ended.")
# Remove file handler and close log file
logMessage.flush()
logMessage.close()
logger.handlers = []
if (sendErrorEmail == "true"):
# Send email
sendEmail(errorMessage)
value = export_dict[k]
for use in fcs_in_workspace(VectorLocation):
count = 0
runID = str(flag) + '_' + str(use)
# print runID
usepath = VectorLocation + os.sep + str(use)
# print dem
usepath = usepath.replace('\\\\', '\\')
#print export_dict
out = export_dict[str(usepath)]
outFC_use = out + os.sep + runID
#print outFC_use
if arcpy.Exists(outFC_use):
print "Already complete analysis for {0}".format(use)
continue
print "Run to " + str(runID)
arcpy.env.overwriteOutput = True
start_loop = datetime.datetime.now()
arcpy.AddField_management(fc, "CoOccur_Acres", "DOUBLE", "#", "#", "#",
"#", "NULLABLE", "NON_REQUIRED", "#")
with arcpy.da.SearchCursor(fc, ("EntityID", "CoOccur_Acres")) as clipper:
for rcrd in clipper:
if rcrd[1] != None:
continue
else:
ent = rcrd[0]
lyr = "Spe_{0}_lyr".format(ent)
if row[1] is None: # "if not filter" did not work on double data type
print "{} ----> EMPTY VALUE FOUND!".format(row[0])
# This can be uncommented to print all successfully populated values:
#else:
#print "Defect_Id: " + str(row[0]) + " ----> " + str(row[1])
print("Testing for missing Chainage values completed")
# Testing: XSP created field values. Are any missing/empty?
print("Testing for missing XSP values:")
with arcpy.da.SearchCursor(de05v3, ("Defect_Id", "XSP")) as cursor:
for row in cursor:
if not filter(None, row[1]):
print "{} ----> EMPTY VALUE FOUND!".format(row[0])
# This can be uncommented to print all successfully populated values:
#else:
#print "Defect_Id: " + str(row[0]) + " ----> " + str(row[1])
print("Testing for missing XSP values completed")
# Delete superseded feature classes and tables:
# Create list of superseded fc/tables
deleteSS = [de05Lyr, de05fc, de05Filter, linearRef]
# Loop through list, deleting the files that are matched
for fcSS in deleteSS:
print("Deleting superseded data: " + fcSS
) # Print each deleted featureclass/table
if arcpy.Exists(fcSS):
arcpy.Delete_management(fcSS)
# Print time taken to run the script
print("Workflow complete in ", time.time() - startTime, " seconds")
def create_gdb(out_folder, out_name, out_path):
if not arcpy.Exists(out_path):
arcpy.CreateFileGDB_management(out_folder, out_name, "CURRENT")
print 'Created GDB {0}'.format(out_name)
def project(dataframe, workspace_in, workspace_out, cellSize, template=False):
arcpy.env.workspace = workspace_in
for i in range(len(dataframe)):
infile = dataframe['Input File Name'][i]
outfile = dataframe['Output File Name'][i]
print("*** infile: ", infile, ", outfile: ", outfile)
outfc = os.path.join(workspace_out, outfile + "_Projected")
# if not dataframe['Process?'][i] == "Yes":
# continue
dsc = arcpy.Describe(infile)
if dsc.spatialReference.Name == "Unknown":
print('skipped this fc due to undefined coordinate system: ' +
infile)
continue
if arcpy.Exists(outfc):
print(
"An output file with this name already exists; skipping projecting this row"
)
if template:
arcpy.env.snapRaster = outfc
print("Now snapping to existing raster")
continue
# if (infile == "gm_lc_v3_2_2"):
# continue
try:
outProj = int(dataframe['Output Projection'][i])
except:
outProj = dataframe['Output Projection'][i]
try:
inProj = int(dataframe['Input Projection'][i])
except:
inProj = dataframe['Input Projection'][i]
if (dataframe['File Type'][i] == 'Feature Class'):
print("Feature Class")
print(infile, outfc, inProj, outProj)
arcpy.Project_management(
infile,
outfc,
out_coor_system=arcpy.SpatialReference(outProj),
in_coor_system=arcpy.SpatialReference(inProj))
print(arcpy.GetMessages())
elif (dataframe['File Type'][i] == 'Raster'):
print("Raster")
print(infile, outfc, inProj, outProj)
arcpy.ProjectRaster_management(
infile,
outfc,
out_coor_system=arcpy.SpatialReference(outProj),
in_coor_system=arcpy.SpatialReference(inProj),
cell_size=cellSize,
resampling_type=dataframe['Resampling Type (for Raster)'][i])
print(arcpy.GetMessages())
if template:
arcpy.env.snapRaster = outfc
print("Now snapping to template raster")
#------------------------------------------------------------------------------
arcpy.AddMessage(" ");
arcpy.AddMessage(str_script);
arcpy.AddMessage("Version: " + str(num_version));
arcpy.AddMessage("By " + str_author);
arcpy.AddMessage("Last Modified: " + str_last_mod);
arcpy.AddMessage(" ");
#------------------------------------------------------------------------------
#- Step 10
#- Verify that the connections exist and are good
#------------------------------------------------------------------------------
arcpy.AddMessage("Validating ArcCatalog Connections:");
ags_con = "GIS Servers\\" + ags_con_name + ".ags";
if arcpy.Exists(ags_con):
arcpy.AddMessage(" Service will be deployed to " + ags_con);
else:
arcpy.AddMessage(" ");
arcpy.AddMessage(" Connection named GIS Servers\\" + ags_con_name + ".ags not found.");
ags_con2 = os.environ['USERPROFILE'] + "\\AppData\\Roaming\\ESRI\\Desktop10.3\\ArcCatalog\\" + ags_con_name + ".ags"
if arcpy.Exists(ags_con2):
ags_con = ags_con2;
arcpy.AddMessage(" Service will be deployed to " + ags_con);
else:
arcpy.AddMessage(" ");
arcpy.AddMessage(" No luck checking " + ags_con2);
ags_con3 = os.environ['USERPROFILE'] + "\\AppData\\Roaming\\ESRI\\Desktop10.2\\ArcCatalog\\" + ags_con_name + ".ags"
def delete_field(featureClass, field):
if arcpy.Exists(featureClass):
try:
arcpy.DeleteField_management(featureClass, field)
except:
config.run_error_message(featureClass, "Delete field failure")
def polygon_cursor_loop(featureClass, pointFeatureClass):
# This loop will add and calculate
if not arcpy.Exists(featureClass):
raise ExistsError
if not arcpy.Exists(pointFeatureClass):
raise ExistsError
try:
polyDupeFlag = 1
nextPolyDupeID, nextPolyTrueDupeID = 0, 0
objNumber, MBRratio, MBRarea, Xlen, Ylen, = 0, 0, 0, 0, 0
polygonCursor, polygonRow, pointCursor, pointRow = None, None, None, None
describeFeatureClass = arcpy.Describe(featureClass)
shapeField = describeFeatureClass.shapeFieldName
polyDupeDict = {}
polyTrueDupeDict = {}
pointCursor = arcpy.InsertCursor(pointFeatureClass)
polygonCursor = arcpy.UpdateCursor(featureClass)
polygonRow = next(polygonCursor)
while polygonRow:
geometry = polygonRow.getValue(shapeField)
polyCentroid = str(geometry.centroid)
polyTrueCentroid = str(geometry.trueCentroid)
MBR = str(geometry.extent)
if polyCentroid != polyTrueCentroid:
polygonRow.setValue("FIP", "YES")
pArea = geometry.area
pointRow = pointCursor.newRow()
Xcent = polyCentroid.split(" ")[0]
Ycent = polyCentroid.split(" ")[1]
Xmin = MBR.split(" ")[0]
Ymin = MBR.split(" ")[1]
Xmax = MBR.split(" ")[2]
Ymax = MBR.split(" ")[3]
Xlen = float(Xmax) - float(Xmin)
Ylen = float(Ymax) - float(Ymin)
MBRarea = Xlen * Ylen
MBRratio = pArea / MBRarea
polygonRow.setValue("P_AREA", pArea)
polygonRow.setValue("RATIO", MBRratio)
objNumber = objNumber + 1
geomPoint = arcpy.CreateObject("Point")
geomPoint.X = str(Xcent)
geomPoint.Y = str(Ycent)
geomPoint.ID = str(objNumber)
pointRow.shape = geomPoint
pointRow.setValue("LINKER", polygonRow.getValue("LINKER"))
#pointRow.ID = geomPoint.ID
pointCursor.insertRow(pointRow)
try:
polyDupeID = polyDupeDict[polyCentroid]
polygonRow.setValue("DUPE", polyDupeFlag)
except:
nextPolyDupeID = nextPolyDupeID + 1
polyDupeID = nextPolyDupeID
polyDupeDict[polyCentroid] = polyDupeID
int_ring = 0
partnum = 0
partcount = geometry.partCount
while partnum < partcount:
part = geometry.getPart(partnum)
pnt = next(part)
pntcount = 0
while pnt:
pnt = next(part)
pntcount += 1
if not pnt:
pnt = next(part)
if pnt:
int_ring = int_ring + 1
partnum += 1
if int_ring > 0:
polygonRow.setValue("VOIDS", int_ring)
polygonCursor.updateRow(polygonRow)
polygonRow = next(polygonCursor)
except:
config.run_error_message(featureClass, "Polygon cursor failure")
finally:
del polygonCursor, polygonRow, pointCursor, pointRow
gc.collect()
def get_count(featureClass):
if arcpy.Exists(featureClass):
result = arcpy.GetCount_management(featureClass)
return str(result)
PopWeight = "Tot_P_GNAF_Weight"
BufferSize = '2 Kilometers'
SearchRadius = 2000
CellSize = 200
MinHotSpotCount = 50
out_path = r"F:\Suicide_Vs_Population\LITS_20200729"
out_gdb = "Incidents_Away_08_17"
out_name = "NSW_Tot_P"
LogFile = r"F:\Suicide_Vs_Population\LITS_20200729\NSW_Tot_P_log"
HoldWorking = True
out_gdb = "{}\{}".format(out_path, out_gdb)
if not arcpy.Exists(out_gdb):
gdb_path, gdb_name = os.path.split(out_gdb)
arcpy.CreateFileGDB_management(gdb_path, gdb_name)
RasterPop = "{}\KDr_PopRes_{}".format(out_gdb, out_name)
PopAlias = "KDr_PopRes_{}".format(out_name)
RasterTopic = "{}\KDr_{}".format(out_gdb, out_name)
RasterAlias = "KDr_{}".format(out_name)
TopicKDv = "{}\KDv_{}".format(out_gdb, out_name)
PointSet = "{}\{}".format(out_gdb, out_name)
OutputKDr = "{}\KDr_PopDiff_{}".format(out_gdb, out_name)
OutputKDv = "{}\KDv_PopDiff_{}".format(out_gdb, out_name)
PopPointSet = "{}\PopPoints_{}".format(out_gdb, out_name)
# The Raster math conversion to vectors will deliver a vecorized raster in the gridcode range 1 - 20
# 20 represents the Most DIFFERENT locations where suicide event density exceeds population density.
def delete_existing_gdb(self, file_to_delete):
if arcpy.Exists(file_to_delete):
arcpy.Delete_management(file_to_delete)
else:
pass
def add_field(fc,field,Type = 'TEXT'):
if arcpy.Exists(fc):
TYPE = [i.name for i in arcpy.ListFields(fc) if i.name == field]
if not TYPE:
arcpy.AddField_management (fc, field, Type, "", "", 500)
def daymet_parameters(config_path, data_name='PPT'):
"""Calculate GSFLOW DAYMET Parameters
Parameters
----------
config_path : str
Project configuration file (.ini) path.
data_name : {'PPT', 'TMAX', 'TMIN', 'ALL'}
DAYMET data type (the default is 'PPT').
Returns
-------
None
"""
# Initialize hru_parameters class
hru = support.HRUParameters(config_path)
# Open input parameter config file
inputs_cfg = ConfigParser.ConfigParser()
try:
inputs_cfg.readfp(open(config_path))
except Exception as e:
logging.error('\nERROR: Config file could not be read, '
'is not an input file, or does not exist\n'
' config_file = {}\n'
' Exception: {}\n'.format(config_path, e))
sys.exit()
# Log DEBUG to file
log_file_name = 'daymet_normals_log.txt'
log_console = logging.FileHandler(filename=os.path.join(
hru.log_ws, log_file_name),
mode='w')
log_console.setLevel(logging.DEBUG)
log_console.setFormatter(logging.Formatter('%(message)s'))
logging.getLogger('').addHandler(log_console)
logging.info('\nGSFLOW DAYMET Parameters')
# DAYMET
daymet_ws = inputs_cfg.get('INPUTS', 'daymet_folder')
daymet_proj_method = inputs_cfg.get('INPUTS', 'prism_projection_method')
daymet_cs = inputs_cfg.getint('INPUTS', 'prism_cellsize')
calc_jh_coef_flag = inputs_cfg.getboolean('INPUTS',
'calc_prism_jh_coef_flag')
# Check input paths
if not arcpy.Exists(hru.polygon_path):
logging.error('\nERROR: Fishnet ({}) does not exist'.format(
hru.polygon_path))
sys.exit()
# Check that DAYMET folder is valid
if not os.path.isdir(daymet_ws):
logging.error(
'\nERROR: DAYMET folder ({}) does not exist'.format(daymet_ws))
sys.exit()
proj_method_list = ['BILINEAR', 'CUBIC', 'NEAREST']
if daymet_proj_method.upper() not in proj_method_list:
logging.error('\nERROR: DAYMET projection method must be: {}'.format(
', '.join(proj_method_list)))
sys.exit()
logging.debug(' Projection method: {}'.format(
daymet_proj_method.upper()))
# Check other inputs
if daymet_cs <= 0:
logging.error('\nERROR: DAYMET cellsize must be greater than 0\n')
sys.exit()
# Set ArcGIS environment variables
arcpy.CheckOutExtension('Spatial')
env.overwriteOutput = True
env.pyramid = 'PYRAMIDS 0'
env.workspace = hru.param_ws
env.scratchWorkspace = hru.scratch_ws
# DAYMET data names
if data_name == 'ALL':
data_name_list = ['PPT', 'TMAX', 'TMIN']
else:
data_name_list = [data_name]
# Set month list
month_list = ['{:02d}'.format(m) for m in range(1, 13)]
# month_list.extend(['annual'])
# Check fields
logging.info('\nAdding DAYMET fields if necessary')
for data_name in data_name_list:
for month in month_list:
support.add_field_func(hru.polygon_path,
'{}_{}'.format(data_name, month), 'DOUBLE')
# Process each DAYMET data type
logging.info('\nProjecting/clipping DAYMET mean monthly rasters')
for data_name in data_name_list:
logging.info('\n{}'.format(data_name))
daymet_normal_re = re.compile(
'daymet_(?P<type>%s)_30yr_normal_(?P<month>\d{2}).img$' %
data_name, re.IGNORECASE)
# Search all files & subfolders in DAYMET folder
# for images that match data type
input_raster_dict = dict()
for root, dirs, files in os.walk(daymet_ws):
for file_name in files:
daymet_normal_match = daymet_normal_re.match(file_name)
if daymet_normal_match:
month_str = daymet_normal_match.group('month')
input_raster_dict[month_str] = os.path.join(
daymet_ws, root, file_name)
if not input_raster_dict:
logging.error(
'\nERROR: No DAYMET rasters were found matching the following '
'pattern:\n {}\n\n'.format(daymet_normal_re.pattern))
logging.error()
sys.exit()
# DAYMET input data workspace
# input_ws = os.path.join(daymet_ws, data_name.lower())
# if not os.path.isdir(input_ws):
# logging.error('\nERROR: The DAYMET {} folder does not exist'.format(
# data_name.lower()))
# sys.exit()
# DAYMET output data workspace
output_ws = os.path.join(hru.param_ws, data_name.lower() + '_rasters')
if not os.path.isdir(output_ws):
os.mkdir(output_ws)
# Remove all non year/month rasters in DAYMET temp folder
logging.info(' Removing existing DAYMET files')
for item in os.listdir(output_ws):
if daymet_normal_re.match(item):
os.remove(os.path.join(output_ws, item))
# Extract, project/resample, clip
# Process images by month
zs_daymet_dict = dict()
# env.extent = hru.extent
for month in month_list:
logging.info(' Month: {}'.format(month))
# Projected/clipped DAYMET raster
input_raster = input_raster_dict[month]
# input_name = 'daymet_{}_30yr_normal_800mM2_{}_bil.bil'.format(
# data_name.lower(), input_month)
# input_raster = os.path.join(input_ws, input_name)
output_name = 'daymet_{}_normal_{}.img'.format(
data_name.lower(), month)
output_raster = os.path.join(output_ws, output_name)
# Set preferred transforms
input_sr = arcpy.sa.Raster(input_raster).spatialReference
transform_str = support.transform_func(hru.sr, input_sr)
if transform_str:
logging.debug(' Transform: {}'.format(transform_str))
# Project DAYMET rasters to HRU coordinate system
# DEADBEEF - Arc10.2 ProjectRaster does not extent
support.project_raster_func(input_raster, output_raster, hru.sr,
daymet_proj_method.upper(), daymet_cs,
transform_str,
'{} {}'.format(hru.ref_x, hru.ref_y),
input_sr, hru)
# arcpy.ProjectRaster_management(
# input_raster, output_raster, hru.sr,
# daymet_proj_method.upper(), daymet_cs, transform_str,
# '{} {}'.format(hru.ref_x, hru.ref_y),
# input_sr)
# Save parameters for calculating zonal stats
zs_field = '{}_{}'.format(data_name, month)
zs_daymet_dict[zs_field] = [output_raster, 'MEAN']
# Cleanup
del input_raster, output_raster, output_name
del input_sr, transform_str, zs_field
# Cleanup
# arcpy.ClearEnvironment('extent')
# Calculate zonal statistics
logging.info('\nCalculating DAYMET zonal statistics')
support.zonal_stats_func(zs_daymet_dict, hru.polygon_path,
hru.point_path, hru)
del zs_daymet_dict
def blockIntersect():
arcpy.AddMessage(" Begining overlay Processing")
if arcpy.Exists("wireless_block_" + theST):
arcpy.Delete_management("wireless_block_" + theST)
theCnt = int(
arcpy.GetCount_management(theFD + "BB_Service_Wireless").getOutput(0))
theBlock = theBlockGDB + "Block_" + theST
myCnt = 1
if theCnt > 0: #if there are records in the wireless shape class
#rows = arcpy.SearchCursor(theFD + "BB_Service_Wireless")
rows = arcpy.SearchCursor(theFD + "BB_Service_Wireless")
for row in rows: #while < theCnt:
myID = row.getValue("OBJECTID")
#arcpy.AddMessage(" Performing overlay " + str(myCnt) + " of " + str(theCnt) + " and O-ID: " + str(myID))
myQry = "TRANSTECH <> 60 AND OBJECTID = " + str(myID)
myLyr = theST + "NotSatellite" + str(myCnt)
#arcpy.AddMessage("theFD=" + theFD)
#arcpy.AddMessage("myLyr=" + myLyr)
#arcpy.AddMessage("myQry=" + myQry)
#arcpy.MakeFeatureLayer_management (theFD + "BB_Service_Wireless", myLyr, myQry)
#arcpy.AddMessage("cnt=" + arcpy.GetCount_management(myLyr).getOutput(0))
if int(
arcpy.GetCount_management(myLyr).getOutput(0)
) > 0: #there are no records in myLyr, it is a satellite record
theOFC = "wireless_block_" + theST + "_" + str(myCnt)
theOFCP = "wireless_block_" + theST + "_" + str(myCnt) + "_prj"
myFCs = [theOFC, theOFCP]
for myFC in myFCs:
if arcpy.Exists(myFC):
arcpy.Delete_management(myFC)
#arcpy.AddMessage("myLyr=" + myLyr)
#arcpy.AddMessage("theBlock=" + theBlock)
#arcpy.AddMessage("theOFC=" + theOFC)
arcpy.Intersect_analysis([myLyr, theBlock], theOFC)
#arcpy.AddMessage("after Intersect_analysis")
arcpy.Project_management(
theOFC, theOFCP,
"PROJCS['North_America_Albers_Equal_Area_Conic',GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Albers'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-96.0],PARAMETER['Standard_Parallel_1',20.0],PARAMETER['Standard_Parallel_2',60.0],PARAMETER['Latitude_Of_Origin',40.0],UNIT['Meter',1.0]]",
"NAD_1983_To_WGS_1984_1",
"GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]"
)
arcpy.AddField_management(theOFCP, "PCT", "DOUBLE", "5", "2",
"")
theExp = "([SHAPE_Area]) /( [ALAND10] + [AWATER10] )*100"
arcpy.CalculateField_management(theOFCP, "PCT", theExp, "VB",
"")
arcpy.Delete_management(myLyr)
if arcpy.Exists(theOFC):
arcpy.Delete_management(theOFC)
myQry = "PCT > 100"
myLyr = theST + "gtOne" + str(myCnt)
arcpy.MakeFeatureLayer_management(theOFCP, myLyr, myQry)
if int(arcpy.GetCount_management(myLyr).getOutput(0)) > 0:
arcpy.CalculateField_management(myLyr, "PCT", "100",
"PYTHON", "")
arcpy.Delete_management(myLyr)
arcpy.CopyRows_management(theOFCP, theOFC)
if arcpy.Exists(theOFCP):
arcpy.Delete_management(theOFCP)
del theExp, theOFCP, theOFC, myFC, myFCs
myCnt = myCnt + 1
del myLyr, myQry, theBlock, theCnt, myCnt, row, rows, myID
return ()
def appendSDMValues(gp, unitCell, TrainPts):
try:
arcpy.AddMessage("\n" + "=" * 10 + " arcsdm values " + "=" * 10)
with open(
os.path.join(os.path.dirname(__file__), "arcsdm_version.txt"),
"r") as myfile:
data = myfile.readlines()
#Print version information
arcpy.AddMessage("%-20s %s" % ("", data[0]))
installinfo = arcpy.GetInstallInfo()
arcpy.AddMessage("%-20s %s (%s)" %
("Arcgis environment: ", installinfo['ProductName'],
installinfo['Version']))
if not gp.workspace:
gp.adderror('Workspace not set')
raise arcpy.ExecuteError("Workspace not set!")
if not (arcpy.Exists(gp.workspace)):
gp.adderror('Workspace %s not found' % (gp.workspace))
raise arcpy.ExecuteError('Workspace %s not found' % (gp.workspace))
desc = arcpy.Describe(gp.workspace)
gp.addmessage("%-20s %s (%s)" %
("Workspace: ", gp.workspace, desc.workspaceType))
if not gp.scratchworkspace:
gp.adderror('Scratch workspace mask not set')
wdesc = arcpy.Describe(gp.scratchworkspace)
gp.addmessage(
"%-20s %s (%s)" %
("Scratch workspace:", gp.scratchworkspace, wdesc.workspaceType))
# TODO: These should be moved to common CHECKENV class/function TR
# Tools wont work if type is different from eachother (joins do not work filesystem->geodatabase! TR
if (wdesc.workspaceType != desc.workspaceType):
gp.AddError(
"Workspace and scratch workspace must be of the same type!")
raise arcpy.ExecuteError("Workspace type mismatch")
mapUnits = getMapUnits()
mapUnits = mapUnits.lower().strip()
if not mapUnits.startswith('meter'):
gp.addError(
'Incorrect output map units: Check units of study area.')
conversion = getMapConversion(mapUnits)
#gp.addMessage("Conversion from map units to km^2: " + str(conversion));
gp.addmessage("%-20s %s" % ('Map Units:', mapUnits))
if not gp.mask:
gp.adderror('Study Area mask not set')
raise arcpy.ExecuteError("Mask not set. Check Environments!")
#AL
else:
if not arcpy.Exists(gp.mask):
gp.addError("Mask " + gp.mask + " not found!")
raise arcpy.ExecuteError("Mask not found")
#gp.AddMessage("Mask set");
desc = gp.describe(gp.mask)
gp.addMessage(
"%-20s %s" %
("Mask:", "\"" + desc.name + "\" and it is " + desc.dataType))
if (desc.dataType == "FeatureLayer"
or desc.dataType == "FeatureClass"):
arcpy.AddWarning(
'Warning: You should only use single value raster type masks!'
)
gp.addMessage("%-20s %s" %
("Mask size:", str(getMaskSize(mapUnits))))
#gp.AddMessage("Masksize: " + str(getMaskSize(mapUnits)));
if not gp.cellsize:
gp.adderror('Study Area cellsize not set')
if (gp.cellsize == "MAXOF"):
arcpy.AddWarning("Cellsize should have definitive value?")
#raise arcpy.ExecuteError("SDMValues: Cellsize must have value");
cellsize = arcpy.env.cellSize #float(str(arcpy.env.cellSize).replace(",","."))
gp.addmessage("%-20s %s" % ("Cell Size:", cellsize))
#gp.addMessage("Debug: " + str(conversion));
total_area = getMaskSize(
mapUnits
) # Now the getMaskSize returns it correctly in sqkm : * cellsize **2 * conversion
#gp.addMessage("Debug));
unitCell = float(unitCell)
num_unit_cells = total_area / unitCell
num_tps = gp.GetCount_management(TrainPts)
gp.addmessage("%-20s %s" % ('# Training Sites:', num_tps))
gp.addmessage("%-20s %s" %
("Unit Cell Area:", "{}km^2, Cells in area: {} ".format(
unitCell, num_unit_cells)))
if (num_unit_cells == 0):
raise arcpy.ExecuteError("ERROR: 0 Cells in Area!")
#AL
priorprob = num_tps / num_unit_cells
if not (0 < priorprob <= 1.0):
arcpy.AddError(
'Incorrect no. of training sites or unit cell area. TrainingPointsResult {}'
.format(priorprob))
raise arcpy.ExecuteError
#raise SDMError('Incorrect no. of training sites or unit cell area. TrainingPointsResult {}'.format(priorprob))
gp.addmessage("%-20s %0.6f" % ('Prior Probability:', priorprob))
#gp.addmessage("Debug priorprob:" + str(getPriorProb(TrainPts, unitCell)))
gp.addmessage("%-20s %s" %
('Training Set:', gp.describe(TrainPts).catalogpath))
gp.addmessage("%-20s %s" %
('Study Area Raster:', gp.describe(gp.mask).catalogpath))
gp.addmessage("%-20s %s" %
('Study Area Area:', str(total_area) + "km^2"))
#gp.addmessage('Map Units to Square Kilometers Conversion: %f'%conversion)
arcpy.AddMessage("")
# Empty line at end
except arcpy.ExecuteError as e:
if not all(e.args):
arcpy.AddMessage("Calculate weights caught arcpy.ExecuteError: ")
args = e.args[0]
args.split('\n')
arcpy.AddError(args)
arcpy.AddMessage("-------------- END EXECUTION ---------------")
raise
except:
# get the traceback object
tb = sys.exc_info()[2]
# tbinfo contains the line number that the code failed on and the code from that line
tbinfo = traceback.format_tb(tb)[0]
gp.addError(tbinfo)
# concatenate information together concerning the error into a message string
#pymsg = "PYTHON ERRORS:\nTraceback Info:\n" + tbinfo + "\nError Info:\n " + \
# str(sys.exc_type)+ ": " + str(sys.exc_value) + "\n"
# generate a message string for any geoprocessing tool errors
if len(gp.GetMessages(2)) > 0:
msgs = "SDM GP ERRORS:\n" + gp.GetMessages(2) + "\n"
gp.AddError(msgs)
#gp.AddError(pymsg)
raise
'name_prefix': 'NUACI2000_'
},
2005: {
'data_dir': u'E:/Data/city_extraction/2005/',
'name_prefix': 'NUACI2005_'
},
2010: {
'data_dir': u'E:/Data/city_extraction/2010/',
'name_prefix': 'NUACI2010_'
},
'output': {
'data_dir': u'E:/Data/city_extraction/cell_statistics/',
'name_prefix': 'NUACI_'
},
'begin_id': 90,
'end_id': 134
}
if __name__ == '__main__':
for id in range(config['begin_id'], config['end_id'] + 1):
raster_list = []
for year in range(1990, 2010 + 1, 5):
file_path = config[year]['data_dir'] + config[year][
'name_prefix'] + str(id) + '.tif'
if arcpy.Exists(file_path):
raster_list.append(file_path)
output_raster = arcpy.sa.CellStatistics(raster_list, 'MAXIMUM')
output_raster.save(config['output']['data_dir'] +
config['output']['name_prefix'] + str(id) + '.tif')
print(id, raster_list, 'finish')
## Loop through raster data, clipping and creating arrays of data: Date Q Ppt
rasSq = 1013.02**2 / 1000 ## ppt [mm -> m] and cellsize (x*y) [m*m]
precip = []
date = []
q = []
for day in rrule.rrule(rrule.DAILY, dtstart=start, until=end):
folder = "C:\\Recharge_GIS\\Precip\\800m\\Daily\\"
yr = day.year
if (yr <= 1991):
arcpy.env.overwriteOutput = True ## Ensure overwrite capability
arcpy.env.workspace = folder + str(day.year) + "a"
ras = folder + str(day.year) + "a\\" + "PRISM_NM_" + str(
day.year) + day.strftime('%m') + day.strftime(
'%d') + ".tif"
if arcpy.Exists(ras):
try:
arcpy.CheckOutExtension("Spatial")
mask = "C:\\Recharge_GIS\\nm_gauges.gdb\\nm_wtrshds"
rasPart = arcpy.sa.ExtractByMask(ras, geo)
if day == beginPrecip:
rasPart.save(folder + str(day.year) + "a\\" +
str(gPoly) + "_rasterClipTest.tif")
arr = arcpy.RasterToNumPyArray(rasPart,
nodata_to_value=0)
arrVal = np.multiply(arr, rasSq)
arrSum = arrVal.sum()
print("Sum of precip on " + str(day) + ": " +
str(arrSum))
precip.append(arrSum)
date.append(day)
def projected_comps(in_lyr, fc, prj_final, region_name, temp_gdb, final_gdb,
prj_location):
# Check if out location was already created
if not arcpy.Exists(temp_gdb):
path, gdb_file = os.path.split(temp_gdb)
create_gdb(path, gdb_file, temp_gdb)
if not arcpy.Exists(final_gdb):
path, gdb_file = os.path.split(final_gdb)
create_gdb(path, gdb_file, final_gdb)
prj_name = prj_final.replace('.prj', '')
prj_name = prj_name.replace(' ', '_')
in_fc = in_lyr
# Locations of WGS and desired projections
wgs_coord_file = prj_location + os.sep + 'WGS 1984.prj'
prj_file = prj_location + os.sep + prj_final
# Extraction spatial info from these prj file
dsc_wgs = arcpy.Describe(wgs_coord_file)
wgs_coord_sys = dsc_wgs.spatialReference
dsc_prj = arcpy.Describe(prj_file)
prj_sr = dsc_prj.spatialReference
prj_datum = prj_sr.GCS.datumName
if not arcpy.Exists(temp_gdb):
path, file_temp = os.path.split(temp_gdb)
create_gdb(path, file_temp, temp_gdb)
if not arcpy.Exists(final_gdb):
path, file_final = os.path.split(final_gdb)
create_gdb(path, file_final, final_gdb)
if prj_datum == "D_WGS_1984":
fc_other_geo = region_name + "_" + str(fc) + "_WGS84"
out_other_fc = temp_gdb + os.sep + fc_other_geo
prj_fc_name = fc_other_geo + "_" + prj_name
prj_fc = final_gdb + os.sep + prj_fc_name
if not arcpy.Exists(out_other_fc):
arcpy.Project_management(in_fc, out_other_fc, wgs_coord_sys)
print(arcpy.GetMessages(0))
if not arcpy.Exists(prj_fc):
arcpy.Project_management(out_other_fc, prj_fc, prj_sr)
print(arcpy.GetMessages(0))
else:
print str(prj_fc) + " already exists"
else:
prj_fc_name = region_name + "_" + str(fc) + "_" + prj_name
prj_fc = final_gdb + os.sep + prj_fc_name
if not arcpy.Exists(prj_fc):
arcpy.Project_management(in_fc, prj_fc, prj_sr)
# print(arcpy.GetMessages(0))
print 'Completed Projecitons for {0}'.format(prj_fc)
else:
pass
return prj_fc
start_script = datetime.datetime.now()
print "Script started at {0}".format(start_script)
species_neg = []
with open(folderDict, 'rU') as inputFile:
header = next(inputFile)
for line in inputFile:
line = line.split(',')
finalGDB = str(line[0])
finalGDB = finalGDB.strip('\n')
use = str(line[1])
use = use.strip('\n')
outtable = finalGDB + os.sep + "Topo_results_" + use
if arcpy.Exists(outtable):
intable = outtable
else:
intable = topolist
print finalGDB
for fc in functions.fcs_in_workspace(finalGDB):
#print fc
current_update = {}
CHchecklist = fc.split("_")
CHcheck = CHchecklist[0]
if CHcheck != 'Topo':
continue
elif str(CHchecklist[1]) == 'T':
continue
def create_structures_fc(gdb):
"""
Create Historic Structures feature class
"""
arcpy.env.workspace = gdb
fc = "HistoricStructures"
spatref = arcpy.SpatialReference(
"WGS 1984 Web Mercator (auxiliary sphere)")
if arcpy.Exists(fc):
arcpy.Delete_management(os.path.join(gdb, fc))
has_m = "DISABLED"
has_z = "DISABLED"
# Execute CreateFeatureclass
arcpy.CreateFeatureclass_management(gdb, fc, "POINT", "", has_m, has_z,
spatref)
arcpy.AddField_management(fc, "ResourceID", "LONG", "", "", "",
"Resource ID", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(fc, "PropName", "TEXT", "", "", 100,
"Resource Name", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(fc, "StrucType", "LONG", "", "", "",
"Structure Type", "NON_NULLABLE", "NON_REQUIRED",
"")
arcpy.AddField_management(fc, "BldType", "TEXT", "", "", 3,
"Building Type", "NON_NULLABLE", "NON_REQUIRED",
"")
arcpy.AddField_management(fc, "StyleType", "TEXT", "", "", 3,
"Architectural Style", "NON_NULLABLE",
"NON_REQUIRED", "")
arcpy.AddField_management(fc, "Eligibility", "TEXT", "", "", 3,
"Eligibility Status", "NON_NULLABLE",
"NON_REQUIRED", "")
arcpy.AddField_management(fc, "ConstYr", "LONG", "", "", "",
"Construction Year", "NULLABLE", "NON_REQUIRED",
"")
arcpy.AddField_management(fc, "Address", "TEXT", "", "", 200, "Address",
"NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(fc, "Notes", "TEXT", "", "", 200, "Notes",
"NULLABLE", "NON_REQUIRED", "")
arcpy.AddGlobalIDs_management(fc)
arcpy.AddField_management(fc, "EPProject", "TEXT", "", "", 20,
"EPEI Project ID", "NULLABLE", "NON_REQUIRED",
"")
arcpy.SetSubtypeField_management(fc, "StrucType")
for item in subtypes.items():
arcpy.AddSubtype_management(fc, item[0], item[1])
arcpy.SetDefaultSubtype_management(fc, 5)
for item in subtypes.items():
arcpy.AssignDomainToField_management(fc, "BldType", item[1], item[0])
arcpy.AssignDomainToField_management(
fc, "StyleType", "Styles",
['0', '1', '2', '3', '4', '5', '6', '7', '8'])
arcpy.AssignDomainToField_management(
fc, "Eligibility", "Eligibility",
['0', '1', '2', '3', '4', '5', '6', '7', '8'])
arcpy.AssignDefaultToField_management(
fc, "Eligibility", "U", ['0', '1', '2', '3', '4', '5', '6', '7', '8'])
arcpy.AssignDefaultToField_management(
fc, "StyleType", "NS", ['0', '1', '2', '3', '4', '5', '6', '7', '8'])
arcpy.AssignDefaultToField_management(
fc, "BldType", "OT", ['0', '1', '2', '3', '4', '6', '7', '8'])
arcpy.AssignDefaultToField_management(fc, "BldType", "NAT", '5')
return os.path.join(gdb, fc)
create_gdb(OutFolderGDB, TopoGDB, outfileTopogdbpath)
DissolveList = [Dissolve, JoinFieldFC]
print DissolveList
for fc in fcs_in_workspace(InGDB):
try:
arcpy.Delete_management("fc_lyr")
arcpy.Delete_management("outfc_lyr")
name = str(fc) + "_STD"
arcpy.MakeFeatureLayer_management(fc, "fc_lyr")
outfc = outFilegdbpath + os.sep + str(name)
topofc = outfileTopogdbpath + os.sep + str(fc)
outFailedFC = outFilefailgdbpath + os.sep + str(fc)
count = int(arcpy.GetCount_management(fc).getOutput(0))
if arcpy.Exists(outfc):
print str(outfc) + ": Already exists"
continue
elif arcpy.Exists(topofc):
print str(outfc) + ":Topo Already exists"
continue
else:
try:
print "Start dissolve: " + str(fc)
arcpy.Dissolve_management("fc_lyr", outfc, DissolveList, "",
"MULTI_PART", "DISSOLVE_LINES")
print "Dissolved: " + str(fc)
except:
topofc = outfileTopogdbpath + os.sep + str(fc)
if arcpy.Exists(topofc):
continue
def CreateGDB(OutFolder, OutName, outpath):
if not arcpy.Exists(outpath):
arcpy.CreateFileGDB_management(OutFolder, OutName, "CURRENT")
def create_gdb(out_folder, out_name, outpath):
if not arcpy.Exists(outpath):
arcpy.CreateFileGDB_management(out_folder, out_name, "CURRENT")
logfile.close()
### START HERE ###
if len(sys.argv) <> 3 or not os.path.exists(sys.argv[1]) or not os.path.exists(
sys.argv[2]):
usage()
else:
addMsgAndPrint(' ' + versionString)
gdb = os.path.abspath(sys.argv[1])
ows = os.path.abspath(sys.argv[2])
arcpy.env.QualifiedFieldNames = False
arcpy.env.overwriteoutput = True
## fix the new workspace name so it is guaranteed to be novel, no overwrite
newgdb = ows + '/xx' + os.path.basename(gdb)
if arcpy.Exists(newgdb):
arcpy.Delete_management(newgdb)
addMsgAndPrint(' Copying ' + os.path.basename(gdb) +
' to temporary geodatabase...')
try:
arcpy.AddMessage("Using Arcpy Copy")
arcpy.Copy_management(gdb, newgdb)
except:
if arcpy.Exists(newgdb):
arcpy.Delete_management(newgdb)
arcpy.AddMessage("Using Shutil CopyTree")
shutil.copytree(gdb,
newgdb) #Not elegent but got around a crashing issue
main(newgdb, ows, gdb)
addMsgAndPrint('\n Deleting temporary geodatabase...')
arcpy.env.workspace = ows
## "SQL_SERVER",
## userDefinedServer,
## "DATABASE_AUTH",
## UserName,
## Password,
## "SAVE_USERNAME",
## state,
## "#",
## "TRANSACTIONAL",
## "sde.DEFAULT")
## except Exception as e:
## print " cursor execute create db connection: {}".format((e))
print "Delete hifld table if it exists, if yes delete it..."
try:
if arcpy.Exists(FC):
arcpy.DeleteFeatures_management(FC)
except Exception as e:
print " arcpy delete hifld table exception: {}".format((e))
print "Copy shapefile to sql server..."
# Name Alias IsNullable Required Length Type Scale Precision MergeRule joinDelimiter DataSource OutputFieldName -1 -1
try:
arcpy.FeatureClassToFeatureClass_conversion(in_features=tempShapefilePath, \
out_path=outPath, \
out_name=outName, \
where_clause=whereClause, \
field_mapping='SiteNumber "SiteNumber" true true false 80 Text 0 0 ,First,#,Runways,SiteNumber,-1,-1;\
StateAbbv "StateAbbv" true true false 80 Text 0 0 ,First,#,Runways,StateAbbv,-1,-1;\
ID "ID" true true false 80 Text 0 0 ,First,#,Runways,ID,-1,-1;\
Length "Length" true true false 10 Long 0 10 ,First,#,Runways,Length_ft,-1,-1;\
oras.save(results)
# else:
# print "Raster Names Do Not Match[",fRas," <> ",ras,"]"
if options.oneras:
(temp_path, initRaster) = os.path.split(options.oneras)
initRasType, initSP, initLay = initRaster.split("_", 2)
for bRas in arraylistB:
(temp_path, ras) = os.path.split(bRas)
rasType, stressPeriod, layer = ras.split("_", 2)
if initRasType == rasType:
if initLay == layer:
outputName = rasType + "_diff_" + stressPeriod + "_" + layer
ras2 = arcpy.Raster(bRas)
ras1 = arcpy.Raster(options.oneras)
oras = ras2 - ras1
results = oWorkspace + "\\" + outputName
if arcpy.TestSchemaLock(results):
print ras2, ' minus ', ras1, ' equals ', outputName
oras.save(results)
elif not arcpy.Exists(results):
print ras2, ' minus ', ras1, ' equals ', outputName
oras.save(results)
else:
print "Output SKIPPED [Schema lock present]. Can't save ", results
else:
print "Layers Do Not Match [", initLay, "<>", layer, "]"
else:
print "Raster Types Do Not Match[", initRasType, "<>", rasType, "]"
print "End of Execution"
##############################
# args
# inFc = featureClass
# minSeparation (in mm on map)
# maxPlotAtScale = 500000
inFc = sys.argv[1]
minSeparation_mm = float(sys.argv[2])
maxPlotAtScale = float(sys.argv[3])
addMsgAndPrint(versionString)
#test for valid input:
# inFc exists and has item PlotAtScale
if not arcpy.Exists(inFc):
forceExit()
fields = arcpy.ListFields(inFc)
fieldNames = []
for field in fields:
fieldNames.append(field.name)
if not 'PlotAtScale' in fieldNames:
addMsgAndPrint('No field PlotAtScale in '+fc+', aborting.')
forceExit()
gdb = os.path.dirname(inFc)
if arcpy.Describe(gdb).dataType == 'FeatureDataset':
gdb = os.path.dirname(gdb)
if os.path.basename(inFc) == 'OrientationPoints':
addMsgAndPrint( 'Populating OrientationPointsDicts' )
