def roadsNonMonoCheck():
try:
# Check out license
print('The result of CheckExtension("Highways") is ' + str(CheckExtension("Highways")) + '.')
if CheckExtension("Highways") == 'Available':
CheckOutExtension("Highways")
# Do the license check before the deletion, so that you don't
# remove data and then not put it back in the case that the
# license is not available.
from arcpy import DetectNonMonotonicRoutes_locref
if Exists(nonMonotonicOutputGDB):
try:
Delete_management(nonMonotonicOutputGDB)
except:
pass
else:
pass
nonMonotonicOutputGDBName = returnGDBOrSDEName(nonMonotonicOutputGDB)
CreateFileGDB_management(mainFolder, nonMonotonicOutputGDBName)
time.sleep(1)
DetectNonMonotonicRoutes_locref(networkToReview, nonMonotonicOutputFC, "Any", "F_Date", "T_Date", "SourceRouteId")
print("The Roads & Highways Non-Monotonic routes check for " + str(networkToReview) + " has completed.\n")
else:
print('The Roads & Highways extension is not currently available.')
print('Skipping R&H Non-Monotonicity check.')
except Exception as Exception1:
# 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 Exception1.message
try:
del Exception1
except:
pass
finally:
try:
# Check the license back in
CheckInExtension("Highways")
except:
pass
def main():
# added variable for FileGDB creation
output_gdb1_name = returnGDBOrSDEName(output_gdb1)
# other prep statements
arcpy.env.overwriteOutput = True
# If the outputGDB doesn't already exist, create it now.
if arcpy.Exists(output_gdb1):
arcpy.Delete_management(output_gdb1)
else:
pass
time.sleep(10)
arcpy.CreateFileGDB_management(mainFolder, output_gdb1_name)
AnalyzePolylines(fc1, route_id_fld1, output_gdb1)
def main():
# added variable for FileGDB creation
output_gdb1_name = returnGDBOrSDEName(output_gdb1)
# other prep statements
arcpy.env.overwriteOutput = True
# If the outputGDB doesn't already exist, create it now.
if arcpy.Exists(output_gdb1):
arcpy.Delete_management(output_gdb1)
else:
pass
time.sleep(10)
arcpy.CreateFileGDB_management(mainFolder, output_gdb1_name)
AnalyzePolylines(fc1, route_id_fld1, output_gdb1)
def mainWithPrefixSets():
# For now, use globals.
# Make into prettier/prefixSetFirst Python later, that uses
# dictionary values for everything, including default dictionary values
# for when the usePrefixSetTestingAndReporting value is false.
# Start a loop
for prefixKeyItem in prefixSetErrorReportingDict.keys():
global prefixKeyString
prefixKeyString = prefixKeyItem
# Then, set the necessary variables from the dict
# for the current prefix set in the list.
prefixKeyItemDict = outerTestDict[prefixKeyItem]
csipDict = prefixKeyItemDict["csipDict"]
global fc1
csip_routes = csipDict["csip_routes"]
fc1 = csip_routes
print("fc1 = " + str(fc1) + ".")
global route_id_fld1
csip_route_id_fld1 = csipDict["csip_route_id_fld1"]
route_id_fld1 = csip_route_id_fld1
print("route_id_fld1 = " + str(route_id_fld1) + ".")
global output_gdb1
csip_output_gdb1 = csipDict["csip_output_gdb1"]
output_gdb1 = csip_output_gdb1
print("output_gdb1 = " + str(output_gdb1) + ".")
# added variable for FileGDB creation
output_gdb1_name = returnGDBOrSDEName(output_gdb1)
# other prep statements
arcpy.env.overwriteOutput = True
# If the outputGDB already exists, delete it.
if arcpy.Exists(output_gdb1):
arcpy.Delete_management(output_gdb1)
else:
pass
time.sleep(10)
# Then, (re)create it.
arcpy.CreateFileGDB_management(mainFolder, output_gdb1_name)
AnalyzePolylines(fc1, route_id_fld1, output_gdb1)
def mainWithPrefixSets():
# For now, use globals.
# Make into prettier/prefixSetFirst Python later, that uses
# dictionary values for everything, including default dictionary values
# for when the usePrefixSetTestingAndReporting value is false.
# Start a loop
for prefixKeyItem in prefixSetErrorReportingDict.keys():
global prefixKeyString
prefixKeyString = prefixKeyItem
# Then, set the necessary variables from the dict
# for the current prefix set in the list.
prefixKeyItemDict = outerTestDict[prefixKeyItem]
csipDict = prefixKeyItemDict["csipDict"]
global fc1
csip_routes = csipDict["csip_routes"]
fc1 = csip_routes
print("fc1 = " + str(fc1) + ".")
global route_id_fld1
csip_route_id_fld1 = csipDict["csip_route_id_fld1"]
route_id_fld1 = csip_route_id_fld1
print("route_id_fld1 = " + str(route_id_fld1) + ".")
global output_gdb1
csip_output_gdb1 = csipDict["csip_output_gdb1"]
output_gdb1 = csip_output_gdb1
print("output_gdb1 = " + str(output_gdb1) + ".")
# added variable for FileGDB creation
output_gdb1_name = returnGDBOrSDEName(output_gdb1)
# other prep statements
arcpy.env.overwriteOutput = True
# If the outputGDB already exists, delete it.
if arcpy.Exists(output_gdb1):
arcpy.Delete_management(output_gdb1)
else:
pass
time.sleep(10)
# Then, (re)create it.
arcpy.CreateFileGDB_management(mainFolder, output_gdb1_name)
AnalyzePolylines(fc1, route_id_fld1, output_gdb1)
from operator import itemgetter, attrgetter, methodcaller ## For sorting.
from arcpy import Array as arcpyArray, Describe, env, Point, Polyline
from arcpy.da import SearchCursor as daSearchCursor, UpdateCursor as daUpdateCursor
from pathFunctions import (returnFeatureClass, returnGDBOrSDEName)
##import math
#from datareviewerchecks_config import (localRouteInputLines,
# localRouteOutputLines)
routeFeaturesFC = r'C:\GIS\Geodatabases\KHUB\Manual_Edit_Aggregation\2017-03-08\Data_Mirroring_12B_AllRegions_IntegrationTest_Source.gdb\All_Road_Centerlines_Copy'
if returnGDBOrSDEName(routeFeaturesFC) != None:
env.workspace = returnGDBOrSDEName(routeFeaturesFC)
else:
pass
print(env.workspace)
#currentXYTolerance = env.XYTolerance
tempDesc = Describe(routeFeaturesFC)
currentSR = tempDesc.spatialReference
currentXYTolerance = currentSR.XYTolerance
print("currentXYTolerance: " + str(currentXYTolerance))
try:
del tempDesc
except:
def routeCreation():
env.workspace = returnGDBOrSDEPath(createRoutesOutputFC)
env.overwriteOutput = 1
'''
# Need to match what Transcend used. -- Done.
routeId = 'SourceRouteId'
measureSource = 'TWO_FIELDS'
fMeasureField = 'SourceFromMeasure'
tMeasureField = 'SourceToMeasure'
coordinatePriority = 'UPPER_LEFT'
measureFactor = 1
measureOffset = 0
ignoreGaps = True
buildIndex = True
'''
# Modifications for County Target Network.
routeId = 'TargetCountyLRSKey'
measureSource = 'Shapelength'
#fMeasureField = 'SourceFromMeasure'
#tMeasureField = 'SourceToMeasure'
coordinatePriority = 'LOWER_LEFT'
measureFactor = 1
measureOffset = 0
ignoreGaps = True
buildIndex = True
routesOutputGDB = returnGDBOrSDEPath(createRoutesOutputFC)
routesOutputGDBName = returnGDBOrSDEName(routesOutputGDB)
# Need to implement a new path function to get the GDB's folder.
routesOutputGDBFolder = mainFolder
if Exists(routesOutputGDB):
Delete_management(routesOutputGDB)
else:
pass
CreateFileGDB_management(routesOutputGDBFolder, routesOutputGDBName)
# Checking to see if the copy for routes output exists.
# If so, remove it.
#if Exists(createRoutesOutputFC):
# Delete_management(createRoutesOutputFC)
#else:
# pass
print("Creating the lrs routes.")
# CreateRoutes_lr GP Tool
CreateRoutes_lr(createRoutesInputFC, routeId, createRoutesOutputFC,
measureSource, fMeasureField, tMeasureField,
coordinatePriority, measureFactor, measureOffset,
ignoreGaps, buildIndex)
print("Adding date fields to " + returnFeatureClass(createRoutesOutputFC) +
".")
#Addfields:
AddField_management(createRoutesOutputFC, "F_Date", "DATE", "", "", "",
"F_Date", nullable)
pyDateExpression = '''def pyFindTheDate():
import time
return time.strftime("%Y/%m/%d")'''
CalculateField_management(createRoutesOutputFC, "F_Date",
"pyFindTheDate()", "PYTHON_9.3",
pyDateExpression)
# T_Date (Date)
AddField_management(createRoutesOutputFC, "T_Date", "DATE", "", "", "",
"T_Date", nullable)
# ---- Add route calibration point creation steps for Start & End points. ----
MakeFeatureLayer_management(createRoutesInputFC, 'tempFeatureLayer')
# Checking to see if the output already exists.
# If so, remove it so that it can be recreated.
if Exists(startCalibrationPoints):
Delete_management(startCalibrationPoints)
else:
pass
if Exists(endCalibrationPoints):
Delete_management(endCalibrationPoints)
else:
pass
# Create 2 fieldInfo objects. Turn off all the fields in each one.
featureDesc = Describe('tempFeatureLayer')
if featureDesc.dataType == "FeatureLayer":
fieldInfo_For_Start_CP_Fields = featureDesc.fieldInfo
fieldInfo_For_End_CP_Fields = featureDesc.fieldInfo
# Use the count property to iterate through all the fields
for index in range(0, fieldInfo_For_Start_CP_Fields.count):
fieldInfo_For_Start_CP_Fields.setVisible(index, 'HIDDEN')
fieldInfo_For_End_CP_Fields.setVisible(index, 'HIDDEN')
# Turn on the needed fields.
visibile_Fields_For_Start_CP_Layer = [routeId, 'SourceFromMeasure']
for visibile_Field in visibile_Fields_For_Start_CP_Layer:
tempIndex = fieldInfo_For_Start_CP_Fields.findFieldByName(
visibile_Field)
fieldInfo_For_Start_CP_Fields.setVisible(tempIndex, 'VISIBLE')
# Create a feature layer that only shows the needed fields.
MakeFeatureLayer_management(createRoutesInputFC,
featureLayerCL_For_Start_CP, "", "",
fieldInfo_For_Start_CP_Fields)
# Use that feature layer to create the 1st calibration point set.
FeatureVerticesToPoints_management(featureLayerCL_For_Start_CP,
startCalibrationPoints, "START")
# Turn on the needed fields.
visibile_Fields_For_End_CP_Layer = [routeId, 'SourceToMeasure']
for visibile_Field in visibile_Fields_For_End_CP_Layer:
tempIndex = fieldInfo_For_End_CP_Fields.findFieldByName(visibile_Field)
fieldInfo_For_End_CP_Fields.setVisible(tempIndex, 'VISIBLE')
# Create a feature layer that only shows the needed fields.
MakeFeatureLayer_management(createRoutesInputFC, featureLayerCL_For_End_CP,
"", "", fieldInfo_For_End_CP_Fields)
# Use that feature layer to create the 2nd calibration point set.
FeatureVerticesToPoints_management(featureLayerCL_For_End_CP,
endCalibrationPoints, "END")
# ---- Merge the Start & End calibration points. ----
# Checking to see if the output already exists.
# If so, remove it so that it can be recreated.
if Exists(mergedCalibrationPoints):
Delete_management(mergedCalibrationPoints)
else:
pass
# RoutesSource_Start_CP.SourceRouteId to CalPts_Merge.RouteId
# RoutesSource_End_CP.SourceRouteId to CalPts_Merge.RouteId
mcp_Field1 = FieldMap()
mcp_Field1.addInputField(startCalibrationPoints, routeId)
mcp_Field1.addInputField(endCalibrationPoints, routeId)
mcp_Field1_OutField = mcp_Field1.outputField
mcp_Field1_OutField.name = 'RouteId'
mcp_Field1_OutField.aliasName = 'RouteId'
mcp_Field1_OutField.type = 'String'
mcp_Field1_OutField.length = 50
mcp_Field1.outputField = mcp_Field1_OutField
# RoutesSource_Start_CP.SourceFromMeasure to CalPts_Merge.Measure
mcp_Field2 = FieldMap()
mcp_Field2.addInputField(startCalibrationPoints, 'SourceFromMeasure')
mcp_Field2.addInputField(endCalibrationPoints, 'SourceToMeasure')
mcp_Field2_OutField = mcp_Field2.outputField
mcp_Field2_OutField.name = 'Measure'
mcp_Field2_OutField.aliasName = 'Measure'
mcp_Field2_OutField.type = 'Double'
mcp_Field2.outputField = mcp_Field2_OutField
# Create a fieldMappings object for the layer merge.
calibrationPointsMappings = FieldMappings()
calibrationPointsMappings.addFieldMap(mcp_Field1)
calibrationPointsMappings.addFieldMap(mcp_Field2)
#Merge the points together into a single feature class.
inputMergeLayers = [startCalibrationPoints, endCalibrationPoints]
Merge_management(inputMergeLayers, mergedCalibrationPoints,
calibrationPointsMappings)
MakeFeatureLayer_management(mergedCalibrationPoints, 'tempMergedPoints')
dissolveFields = ["RouteId", "Measure"]
print('Dissolving points.')
Dissolve_management('tempMergedPoints', dissolvedCalibrationPoints,
dissolveFields, "#", "SINGLE_PART")
def reviewData():
try:
print("Starting the Data Reviewer batch job at:\n" +
str(reviewerBatchJob) + ".")
print("For the data located in:\n" + str(workspaceToReview) + ".")
print(
"If one of the feature classes, Routes or CalPts, does not exist in the place that the"
)
print(
"data reviewer batch job looks for it, then you will get an 'Unknown Error'."
)
print(
"This can be remedied by updating the data reviewer batch job's workspace settings."
)
# Test the data reviewer part:
if CheckExtension("datareviewer") == 'Available':
print("Extension availability check complete.")
CheckOutExtension("datareviewer")
# Checking to see if the output already exists.
# If so, remove it so that it can be recreated. -- For the errors, might need a better process, so that
# it's possible to track where the errors were at the start and how things progressed.
if Exists(reviewerSessionGDB):
Delete_management(reviewerSessionGDB)
else:
pass
# Create new geodatabase
# Replace with returnGDBOrSDEPath(reviewerSessionGDB), returnGDBOrSDEName(reviewerSessionGDB)
# or similar functions
CreateFileGDB_management(reviewerSessionGDBFolder,
returnGDBOrSDEName(reviewerSessionGDB))
# Execute EnableDataReviewer
EnableDataReviewer_Reviewer(reviewerSessionGDB, "#", "#",
"DEFAULTS")
# Create a new Reviewer session
##CreateReviewerSession_Reviewer (reviewer_workspace, session_name, {session_template}, {duplicate_checking}, {store_geometry}, {username}, {version})
CreateReviewerSession_Reviewer(reviewerSessionGDB, reviewerSession,
"", "NONE", "STORE_GEOMETRY")
# execute the batch job
batchJobResult = ExecuteReviewerBatchJob_Reviewer(
reviewerSessionGDB, sessionReviewerSession, reviewerBatchJob,
workspaceToReview)
print("Data Reviewer batch job complete.")
# get the output table view from the result object
outputTable = batchJobResult.getOutput(0)
print("The output table is called " + str(outputTable.name) + "."
) # prints REVBATCHRUNTABLE
CheckInExtension("datareviewer")
else:
print(
"The 'datareviewer' extension is not available. Skipping checks."
)
except Exception as Exception1:
# 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 Exception1.message
try:
del Exception1
except:
pass
finally:
CheckInExtension("datareviewer")
def main():
if usePrefixSetTestingAndReporting == True:
for prefixKey in prefixSetErrorReportingDict.keys():
prefixAttributeQuery = prefixSetErrorReportingDict[prefixKey]
prefixKeyItemDict = outerTestDict[prefixKey]
prefixSetGdbBaseName = prefixKeyItemDict["prefixSetGdbBaseName"]
prefixSetSourceGDBName = prefixSetGdbBaseName + '_Source.gdb'
prefixSetSourceGDBLocation = os.path.join(mainFolder,
prefixSetSourceGDBName)
routesSourceOutputLocation = os.path.join(
prefixSetSourceGDBLocation, 'RoutesSource')
try:
Delete_management(
routesSourceFCAsALayer
) #pre-emptive layer delete prior to rebuilding it
time.sleep(3)
except:
pass
MakeFeatureLayer_management(routesSourceFC, routesSourceFCAsALayer)
routesSourceSelectionClause = """ """ + str(
prefixAttributeQuery) + """ """
SelectLayerByAttribute_management(routesSourceFCAsALayer,
"NEW_SELECTION",
routesSourceSelectionClause)
if Exists(returnGDBOrSDEPath(routesSourceOutputLocation)):
pass
else:
CreateFileGDB_management(
mainFolder,
returnGDBOrSDEName(
returnGDBOrSDEPath(routesSourceOutputLocation)))
# Checking to see if the output already exists.
# If so, remove it.
if Exists(routesSourceOutputLocation):
print(
"Deleting the previous routesSourceOutputLocation at: \n" +
str(routesSourceOutputLocation) + ".")
Delete_management(routesSourceOutputLocation)
time.sleep(7)
else:
pass
# Create a new file for the output.
print(
"Making a copy of the selection in the routesSourceFCAsALayer at: \n"
+ routesSourceOutputLocation + ".")
CopyFeatures_management(routesSourceFCAsALayer,
routesSourceOutputLocation)
#Repeat for each of the other layers to be copied into the new *_Source.gdb.
for itemToCopy in otherFCsToCopyList:
itemToCopyInputLocation = os.path.join(
returnGDBOrSDEPath(routesSourceFC), itemToCopy)
itemToCopyOutputLocation = os.path.join(
prefixSetSourceGDBLocation, itemToCopy)
if Exists(itemToCopyOutputLocation):
print(
"Deleting the previous itemToCopyOutputLocation at: \n"
+ str(itemToCopyOutputLocation) + ".")
Delete_management(itemToCopyOutputLocation)
time.sleep(7)
else:
pass
print("Making a copy of the itemToCopy at: \n" +
str(itemToCopyOutputLocation) + ".")
CopyFeatures_management(itemToCopyInputLocation,
itemToCopyOutputLocation)
else:
print(
"The usePrefixSetTestingAndReporting value is not True. Will not create separate prefix set gdbs."
)
def exportErrorsToFeatureClasses(reviewTable, originGDB, errorOutputGDB,
errorOutputGDBFolder):
# Checking to see if the output already exists.
# If so, remove it.
if Exists(errorOutputGDB):
Delete_management(errorOutputGDB)
else:
pass
CreateFileGDB_management(errorOutputGDBFolder,
returnGDBOrSDEName(errorOutputGDB))
previousWorkspace = env.workspace
env.workspace = errorOutputGDB
tableFields = ['ORIGINTABLE', 'CHECKTITLE', 'OBJECTID']
newCursor = daSearchCursor(reviewTable, tableFields)
revRows = list()
for rowItem in newCursor:
revRows.append(list(rowItem))
try:
del newCursor
except:
pass
originTableList = list()
checkTitleList = list()
for revRowItem in revRows:
originTableList.append(revRowItem[0])
checkTitleList.append(revRowItem[1])
print('Creating sets from the originTable and checkTitle lists.')
originTableSet = set(originTableList)
checkTitleSet = set(checkTitleList)
print('Finished set creation.')
originTableList = list(originTableSet)
checkTitleList = list(checkTitleSet)
tableAndCheckDataObjects = list()
csvDictOfErrorFeatures = dict()
for originTableItem in originTableList:
print('Origin table = ' + originTableItem + '.')
completeOriginTablePath = os.path.join(originGDB, originTableItem)
print('The full path to the origin table is ' +
str(completeOriginTablePath) + '.')
tableViewName = "ReviewTable_View_" + str(originTableItem)
originTableWhereClause = """"ORIGINTABLE" = '""" + str(
originTableItem) + """'"""
try:
Delete_management(tableViewName)
except:
pass
MakeTableView_management(reviewTable, tableViewName,
originTableWhereClause)
for checkTitleItem in checkTitleList:
print('Check title = ' + checkTitleItem + '.')
selectionWhereClause = """"CHECKTITLE" = '""" + str(
checkTitleItem) + """'"""
SelectLayerByAttribute_management(tableViewName, "NEW_SELECTION",
selectionWhereClause)
countResult = GetCount_management(tableViewName)
intCount = int(countResult.getOutput(0))
if intCount >= 1:
tempTableAndCheckData = tableAndCheckData(
originTableItem, checkTitleItem)
tableViewFields = ["RECORDID", "OBJECTID"]
newCursor = daSearchCursor(tableViewName, tableViewFields,
selectionWhereClause)
newOIDList = list()
for cursorItem in newCursor:
newOIDList.append(cursorItem[1])
try:
del newCursor
except:
pass
tempTableAndCheckData.listOfOIDsToUse = newOIDList
tableAndCheckDataObjects.append(tempTableAndCheckData)
else:
print("There were no features selected for the " +
tableViewName + " table.")
print("There are " + str(len(tableAndCheckDataObjects)) +
" different items in the tableAndCheckDataObjects list.")
for listObject in tableAndCheckDataObjects:
featureLayerForErrorOutput = 'FeatureClassAsFeatureLayer'
if Exists(featureLayerForErrorOutput):
Delete_management(featureLayerForErrorOutput)
else:
pass
fullPathToFeatureClass = os.path.join(originTablesGDB,
listObject.tableName)
MakeFeatureLayer_management(fullPathToFeatureClass,
featureLayerForErrorOutput)
# build the selection list & select up to but not more than 999 features at at time
OIDTotalCounter = 0
errorOutputWhereClause = """ "OBJECTID" IN ("""
for errorOID in listObject.listOfOIDsToUse:
if OIDTotalCounter <= 998:
errorOutputWhereClause = errorOutputWhereClause + str(
errorOID) + """, """
OIDTotalCounter += 1
else:
# Remove the trailing ", " and add a closing parenthesis.
errorOutputWhereClause = errorOutputWhereClause[:-2] + """) """
SelectLayerByAttribute_management(featureLayerForErrorOutput,
"ADD_TO_SELECTION",
errorOutputWhereClause)
OIDTotalCounter = 0
errorOutputWhereClause = """ "OBJECTID" IN ("""
errorOutputWhereClause = errorOutputWhereClause + str(
errorOID) + """, """
# Remove the trailing ", " and add a closing parenthesis.
errorOutputWhereClause = errorOutputWhereClause[:-2] + """) """
SelectLayerByAttribute_management(featureLayerForErrorOutput,
"ADD_TO_SELECTION",
errorOutputWhereClause)
##print "Counting..."
selectedErrorsResult = GetCount_management(featureLayerForErrorOutput)
selectedErrorsCount = int(selectedErrorsResult.getOutput(0))
# export the selected data with the correct tableName & checkTitle
outputFeatureClassName = formatCheckTitle(
listObject.checkTitle) + "ErrorsFrom_" + listObject.tableName
fullPathToOutputFeatureClass = os.path.join(errorOutputGDB,
outputFeatureClassName)
csvDictOfErrorFeatures[outputFeatureClassName] = str(
selectedErrorsCount)
print(
str(selectedErrorsCount) + "\t features will be written to \t" +
outputFeatureClassName)
if selectedErrorsCount >= 1:
CopyFeatures_management(featureLayerForErrorOutput,
fullPathToOutputFeatureClass)
time.sleep(25)
AddField_management(outputFeatureClassName, "OptionalInfo", "TEXT",
"", "", 250, "ReviewingInfo", nullable)
else:
pass
# Need to write a short CSV here that tells the number and type of errors.
print('Writing error information to an error reports file called ' +
str(errorReportCSVName) + '.')
try:
with open(errorReportCSV, 'w') as fHandle:
for errorFeature in errorReportRowsOrder:
if errorFeature in csvDictOfErrorFeatures:
errorFeatureCount = csvDictOfErrorFeatures[errorFeature]
fHandle.write(
str(errorFeature) + ', ' + str(errorFeatureCount) +
'\n')
else:
fHandle.write(str(errorFeature) + ', ' + str(0) + '\n')
# Add a blank line to match previous formatting.
fHandle.write('\n')
except:
print("There was an error writing to the file.")
# Modify this so that it just checks for the existence of the roads
# and highways check output, rather than relying on the config
# file for whether or not this should be ran.
# The config file can tell the full process whether or not
# to run the R&H check, but the error report should give
# details on the R&H check whether or not the config file
# currently states that the R&H check should be ran again
# were the full process to run.
env.workspace = previousWorkspace
def mainProcessFeatureSimplification(inputFeatures, maxCount, outputFeatures):
# Split the input features into intermediary features:
# Add each intermediary feature class to a list and
# pass one feature class of the intermediary features
# to each subprocess.
# When all of the subprocesses complete, use the
# list of the intermediary feature classes to append
# the data into the output features.
countResult = GetCount_management(inputFeatures)
intCount = int(countResult.getOutput(0))
# debug print
print("Counted " + str(intCount) + " features in the " + inputFeatures + " feature class.")
if maxCount > 15000:
maxCount = 15000
elif maxCount < 2000:
maxCount = 7000
else:
pass
neededMirrors = intCount / maxCount + 1
# debug print
print("Will create " + str(neededMirrors) + " reflection gdbs.")
infoForSubprocess = list()
gdbToCreateList = list()
for countItem in xrange(0, neededMirrors):
gdbMirrorName = mirrorBaseName + '_' + '0' + str(countItem) + '.gdb'
gdbMirrorFullPath = os.path.join(mainFolder, gdbMirrorName)
gdbToCreateList.append(gdbMirrorFullPath)
try:
if Exists(gdbMirrorFullPath):
try:
Delete_management(gdbMirrorFullPath)
except:
pass
else:
pass
except:
pass
CreateFileGDB_management(mainFolder, gdbMirrorName)
# do a selection on the input features here
# then copyfeatures to get the selected features
# output to the target gdb.
if Exists(simplifyTempLayer):
try:
Delete_management(simplifyTempLayer)
except:
pass
else:
pass
MakeFeatureLayer_management(inputFeatures, simplifyTempLayer)
currentSelectMin = int(countItem * maxCount)
currentSelectMax = int((countItem + 1) * maxCount)
dynSelectClause = """"OBJECTID" >= """ + str(currentSelectMin) + """ AND "OBJECTID" < """ + str(currentSelectMax) + """"""
SelectLayerByAttribute_management(simplifyTempLayer, "NEW_SELECTION", dynSelectClause)
selectedSimplifyFeatures = os.path.join(gdbMirrorFullPath, simplifyInputName)
CopyFeatures_management(simplifyTempLayer, selectedSimplifyFeatures)
subprocessInfoItem = [mainFolder, gdbMirrorFullPath, simplifyAlgorithm, simplifyDistance]
infoForSubprocess.append(subprocessInfoItem)
# Predivide the list of data driven pages that each process needs to run
# and pass it as a list of exportItems.
coreCount = mp.cpu_count()
# To support running this on the slow AR60, reduce the coreCount used to try to keep
# this script from crashing there.
if coreCount >= 3 and useMultithreading == True:
coreCount = coreCount - 1
print("Starting a multi-threaded job which will use (up to) " + str(coreCount) + " cores at once.")
workPool = mp.Pool(processes=coreCount)
# Note: This is a different usage of the word map than the one generally used in GIS.
workPool.map(subProcessFeatureSimplification, infoForSubprocess)
print("Multi-threaded job's done!")
print("Waiting a few moments before closing down the worker processes...")
time.sleep(20)
workPool.close()
time.sleep(20)
workPool.join()
print("Worker processes closed.")
else:
# Don't use multithreading here.
print("Using the single threaded process for feature simplification.")
print("This will be slower than the multi-threaded version,")
print("but it should also be less likely to crash on slower machines")
print("or those with low core counts.")
for singleThreadedProcessInfoListItem in infoForSubprocess:
singleThreadedProcessForSlowMachines(singleThreadedProcessInfoListItem)
print("Waiting a few moments before continuing to the next part of the script...")
time.sleep(20)
# Delete the output target prior to recreating it and appending data into it.
if Exists(outputFeatures):
try:
Delete_management(outputFeatures)
except:
pass
else:
pass
# Need the gdb and fc name here from outputFeatures.
outGDB = returnGDBOrSDEPath(outputFeatures)
outGDBName = returnGDBOrSDEName(outGDB)
outGDBFolder = returnGDBOrSDEFolder(outGDB)
outFCName = returnFeatureClass(outputFeatures)
if not Exists(outGDB):
CreateFileGDB_management(outGDBFolder, outGDBName)
# Use the inputFeatures as a template.
CreateFeatureclass_management(outGDB, outFCName, "", inputFeatures)
appendOutputFCList = list()
for gdbToCreate in gdbToCreateList:
appendOutputFC = os.path.join(gdbToCreate, 'simplificationOutput')
appendOutputFCList.append(appendOutputFC)
# Do appends here, then sleep again for a bit.
# Shouldn't need a field mapping since they should all be the same.
Append_management(appendOutputFCList, outputFeatures, "NO_TEST")
print "Waiting a few moments to be sure that all of the locks have been removed prior to deleting the reflection gdbs..."
time.sleep(20)
# Then remove the mirror gdbs.
for gdbToCreate in gdbToCreateList:
try:
if Exists(gdbToCreate):
try:
Delete_management(gdbToCreate)
except:
pass
else:
pass
except:
pass
