arcpy.SetProgressorLabel( "The progress is runing dis,please wait for several minutes...") dis = (PC1 * PC1 * 0.166 + PC2 * PC2 * 0.166 + PC3 * PC3 * 0.166 + PC4 * PC4 * 0.166 + PC5 * PC5 * 0.166 + PC6 * PC6 * 0.166)**0.5 dis.save(outPut + "/dis") myremap = RemapRange([[0, 0.1, 1], [0.1, 100, 2]]) arcpy.SetProgressorLabel( "The progress is recalssifation, please wait for several minutes...") redis = Reclassify(dis, "Value", myremap) arcpy.SetProgressorLabel( "The progress is saving redis, please wait for several minutes...") redis.save(outPut + "/redis") #------------------------------To calculate suitable soil regions--------------------------------------------# table = outPut + "/table" print table arcpy.CopyRows_management(input, table) arcpy.CopyRows_management("HWSD_SMU", outPut + "/HWSD_SMU") arcpy.CopyRows_management("HWSD_DATA", outPut + "/HWSD_DATA") table_listfield = arcpy.ListFields(table) fieldName = [] for tt in table_listfield: fieldName.append(tt.name) if 'SU_CODE' not in fieldName: arcpy.JoinField_management(table, "hwsd", outPut + "/HWSD_SMU", "MU_GLOBAL", "SU_CODE;MU_GLOBAL") arcpy.JoinField_management( table, "MU_GLOBAL", outPut + "/HWSD_DATA", "MU_GLOBAL", "T_GRAVEL;T_SAND;T_SILT;T_CLAY;T_USDA_TEX_CLASS;T_REF_BULK_DENSI;T_BULK_DENSITY;T_OC;T_PH_H2O;T_CEC_CLAY;T_CEC_SOIL;T_BS;T_TEB;T_CACO3;T_CASO4;T_ESP;T_ECE" )
def DrawRadialFlows(): # Get the value of the input parameter inTable = arcpy.GetParameterAsText(0) startX_field = arcpy.GetParameterAsText(1) startY_field = arcpy.GetParameterAsText(2) endX_field = arcpy.GetParameterAsText(3) endY_field = arcpy.GetParameterAsText(4) id_field = arcpy.GetParameterAsText(5) lineType_str = arcpy.GetParameterAsText(6) spRef = arcpy.GetParameterAsText(7) joinFields = arcpy.GetParameterAsText(8) joinFields = joinFields.split(";") isChecked_AddNodes = arcpy.GetParameter(9) outFlowsLyrName = arcpy.GetParameterAsText(10) outNodesLyrName = arcpy.GetParameterAsText(11) if inTable and inTable != "#": try: # create empty list to append all output layers outList = [] if isChecked_AddNodes and outNodesLyrName != '': # Make XY Event Layer (temporary) # Local variable: nodesXY = r"in_memory\nodes_lyr" arcpy.AddMessage('Creating Nodes at Flow Destinations ...') arcpy.SetProgressorLabel( 'Creating Nodes at Flow Destinations ...') arcpy.MakeXYEventLayer_management(table=inTable, in_x_field=endX_field, in_y_field=endY_field, out_layer=nodesXY) # Copy XY Event Layer to Feature Class nodesOutputFC = os.path.join(arcpy.env.scratchGDB, outNodesLyrName) arcpy.CopyFeatures_management(in_features=nodesXY, out_feature_class=nodesOutputFC) outList.append(nodesOutputFC) # XY To Line flowsOutputFC = os.path.join(arcpy.env.scratchGDB, outFlowsLyrName) arcpy.AddMessage('Saved Flow Lines to: ' + flowsOutputFC) arcpy.SetProgressorLabel('Creating Radial Flow Lines ...') if id_field: arcpy.XYToLine_management(in_table=inTable, out_featureclass=flowsOutputFC, startx_field=startX_field, starty_field=startY_field, endx_field=endX_field, endy_field=endY_field, line_type=lineType_str, id_field=id_field, spatial_reference=spRef) if joinFields[0] != '': ### IF any Join Fields are specified, then Copy Rows first and Join that to the input table ### arcpy.AddMessage('Creating Temporary Join Table ...') arcpy.SetProgressorLabel( 'Creating Temporary Join Table ...') ### Copy Rows from Input Table to make sure it has an OID ### outTable = r"in_memory\tempTable" arcpy.CopyRows_management(inTable, outTable) ### JOIN ### arcpy.AddMessage('Joining Selected Fields ...') arcpy.SetProgressorLabel('Joining Selected Fields ...') arcpy.JoinField_management(in_data=flowsOutputFC, in_field=id_field, join_table=outTable, join_field=id_field, fields=joinFields) else: arcpy.AddWarning( "WARNING: No join fields have been selected. Only the ID field will be copied to the output feature class!" ) else: arcpy.XYToLine_management(in_table=inTable, out_featureclass=flowsOutputFC, startx_field=startX_field, starty_field=startY_field, endx_field=endX_field, endy_field=endY_field, line_type=lineType_str, spatial_reference=spRef) outList.append(flowsOutputFC) # Send string of (derived) output parameters back to the tool results = ";".join(outList) # Send string of (derived) output parameters back to the tool arcpy.SetParameterAsText(12, results) arcpy.ResetProgressor() except Exception: e = sys.exc_info()[1] arcpy.AddError('An error occurred: {}'.format(e.args[0]))
def tableTo2PointLine(inputTable, inputStartCoordinateFormat, inputStartXField, inputStartYField, inputEndCoordinateFormat, inputEndXField, inputEndYField, outputLineFeatures, inputLineType, inputSpatialReference): ''' Creates line features from a start point coordinate and an endpoint coordinate. inputTable - Input Table inputStartCoordinateFormat - Start Point Format (from Value List) inputStartXField - Start X Field (longitude, UTM, MGRS, USNG, GARS, GEOREF)(from Input Table) inputStartYField - Start Y Field (latitude)(from Input Table) inputEndCoordinateFormat - End Point Format (from Value List) inputEndXField - End X Field (longitude, UTM, MGRS, USNG, GARS, GEOREF)(from Input Table) inputEndYField - End Y Field (latitude) (from Input Table) outputLineFeatures - Output Line inputLineType - Line Type (from Value List) inputSpatialReference - Spatial Reference, default is GCS_WGS_1984 returns line feature class inputStartCoordinateFormat and inputEndCoordinateFormat must be one of the following: * DD_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DD_2: Longitude and latitude values are in two separate fields. * DDM_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DDM_2: Longitude and latitude values are in two separate fields. * DMS_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DMS_2: Longitude and latitude values are in two separate fields. * GARS: Global Area Reference System. Based on latitude and longitude, it divides and subdivides the world into cells. * GEOREF: World Geographic Reference System. A grid-based system that divides the world into 15-degree quadrangles and then subdivides into smaller quadrangles. * UTM_ZONES: The letter N or S after the UTM zone number designates only North or South hemisphere. * UTM_BANDS: The letter after the UTM zone number designates one of the 20 latitude bands. N or S does not designate a hemisphere. * USNG: United States National Grid. Almost exactly the same as MGRS but uses North American Datum 1983 (NAD83) as its datum. * MGRS: Military Grid Reference System. Follows the UTM coordinates and divides the world into 6-degree longitude and 20 latitude bands, but MGRS then further subdivides the grid zones into smaller 100,000-meter grids. These 100,000-meter grids are then divided into 10,000-meter, 1,000-meter, 100-meter, 10-meter, and 1-meter grids. inputLineType must be one of the following: * GEODESIC: * GREAT_CIRCLE: * RHUMB_LINE: * NORMAL_SECTION: ''' try: # get/set environment env.overwriteOutput = True deleteme = [] scratch = '%scratchGDB%' joinFieldName = "JoinID" startXFieldName = "startX" startYFieldName = "startY" endXFieldName = "endX" endYFieldName = "endY" if env.scratchWorkspace: scratch = env.scratchWorkspace inputSpatialReference = _checkSpatialRef(inputSpatialReference) copyRows = os.path.join(scratch, "copyRows") arcpy.CopyRows_management(inputTable, copyRows) originalTableFieldNames = _tableFieldNames(inputTable, joinExcludeFields) addUniqueRowID(copyRows, joinFieldName) #Convert Start Point arcpy.AddMessage("Formatting start point...") startCCN = os.path.join(scratch, "startCCN") arcpy.ConvertCoordinateNotation_management(copyRows, startCCN, inputStartXField, inputStartYField, inputStartCoordinateFormat, "DD_NUMERIC", joinFieldName) arcpy.AddField_management(startCCN, startXFieldName, "DOUBLE") arcpy.CalculateField_management(startCCN, startXFieldName, "!DDLon!", "PYTHON_9.3") arcpy.AddField_management(startCCN, startYFieldName, "DOUBLE") arcpy.CalculateField_management(startCCN, startYFieldName, "!DDLat!", "PYTHON_9.3") arcpy.JoinField_management(copyRows, joinFieldName, startCCN, joinFieldName, [startXFieldName, startYFieldName]) #Convert End Point arcpy.AddMessage("Formatting end point...") endCCN = os.path.join(scratch, "endCCN") arcpy.ConvertCoordinateNotation_management(copyRows, endCCN, inputEndXField, inputEndYField, inputEndCoordinateFormat, "DD_NUMERIC", joinFieldName) arcpy.AddField_management(endCCN, endXFieldName, "DOUBLE") arcpy.CalculateField_management(endCCN, endXFieldName, "!DDLon!", "PYTHON_9.3") arcpy.AddField_management(endCCN, endYFieldName, "DOUBLE") arcpy.CalculateField_management(endCCN, endYFieldName, "!DDLat!", "PYTHON_9.3") arcpy.JoinField_management(copyRows, joinFieldName, endCCN, joinFieldName, [endXFieldName, endYFieldName]) #XY TO LINE arcpy.AddMessage( "Connecting start point to end point as {0}...".format( inputLineType)) arcpy.XYToLine_management(copyRows, outputLineFeatures, startXFieldName, startYFieldName, endXFieldName, endYFieldName, inputLineType, joinFieldName, inputSpatialReference) #Join original table fields to output arcpy.AddMessage( "Joining fields from input table to output line features...") arcpy.JoinField_management(outputLineFeatures, joinFieldName, copyRows, joinFieldName, originalTableFieldNames) arcpy.DeleteField_management(outputLineFeatures, [ joinFieldName, startXFieldName, startYFieldName, endXFieldName, endYFieldName ]) return outputLineFeatures except arcpy.ExecuteError: # Get the tool error messages msgs = arcpy.GetMessages() arcpy.AddError(msgs) print(msgs) except: # Get the traceback object tb = sys.exc_info()[2] tbinfo = traceback.format_tb(tb)[0] # Concatenate information together concerning the error into a message string pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str( sys.exc_info()[1]) msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages() + "\n" # Return python error messages for use in script tool or Python Window arcpy.AddError(pymsg) arcpy.AddError(msgs) # Print Python error messages for use in Python / Python Window print(pymsg + "\n") print(msgs) finally: if len(deleteme) > 0: # cleanup intermediate datasets if debug == True: arcpy.AddMessage("Removing intermediate datasets...") for i in deleteme: if debug == True: arcpy.AddMessage("Removing: " + str(i)) arcpy.Delete_management(i) if debug == True: arcpy.AddMessage("Done")
if b_createPools: if not createPool(maxElevConverted, storageCSV): pass maxElevConverted = maxElevConverted - increment del i except: print_exception() sys.exit() if arcpy.Exists(tempDEM): arcpy.Delete_management(tempDEM) #------------------------------------------------------------------------ Convert StorageCSV to FGDB Table and populate fields. arcpy.CopyRows_management(storageCSV, storageTable, "") arcpy.AddField_management(storageTable, "ELEV_FEET", "DOUBLE", "5", "1", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(storageTable, "POOL_ACRES", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(storageTable, "POOL_SQFT", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(storageTable, "ACRE_FOOT", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") elevFeetCalc = "round(!Plane_Height! *" + str(conversionFactor) + ",1)" poolAcresCalc = "round(!Area_2D! /" + str(acreConversion) + ",1)" poolSqftCalc = "round(!Area_2D! /" + str(ftConversion) + ",1)" acreFootCalc = "round(!Volume! /" + str(volConversion) + ",1)" arcpy.CalculateField_management(storageTable, "ELEV_FEET", elevFeetCalc,
expression = "round(!stationElev.MEAN! * " + str(Zfactor) + ",1)" arcpy.CalculateField_management(stationLyr, "stations.POINT_Z", expression, "PYTHON") arcpy.RemoveJoin_management(stationLyr, "stationElev") arcpy.DeleteField_management(stationTemp, "STATIONID; POINT_M") del expression # ---------------------------------------------------------------------- Create final output # Interpolate Line to 3d via Z factor arcpy.InterpolateShape_3d(DEM_aoi, lineTemp, outLine, "", Zfactor) # Copy Station Points arcpy.CopyFeatures_management(stationTemp, outPoints) # Copy output to tables folder arcpy.CopyRows_management(outPoints, pointsTable, "") #arcpy.CopyRows_management(stakeoutPoints, stakeoutTable, "") # Redundant to the wascobStations script. Doesn't do anything here. # ------------------------------------------------------------------- Delete Temp Layers AddMsgAndPrint("\nDeleting temporary files...", 0) layersToRemove = (lineTemp, routes, stationTable, stationEvents, stationTemp, stationLyr, stationBuffer, stationElev) x = 0 for layer in layersToRemove: if arcpy.Exists(layer): if x == 0: x += 1 try: arcpy.Delete_management(layer) except:
# Import arcpy module import arcpy # Script arguments Jeopardy_CSV_File = arcpy.GetParameterAsText(0) if Jeopardy_CSV_File == '#' or not Jeopardy_CSV_File: Jeopardy_CSV_File = "C:\\Users\\jvwhit\\Documents\\GitHub\\Python-For-ArcGIS-2017\\Advanced_PythonForArcGIS\\Data\\Answers_Adv\\CSV\\JeopardyContestants_LatLon.csv" # provide a default value if unspecified # Local variables: JeopardyContestants_Table = "C:\\Users\\jvwhit\\Documents\\GitHub\\Python-For-ArcGIS-2017\\Advanced_PythonForArcGIS\\Data\\Answers_Adv\\Illinois.gdb\\JeopardyContestants_Table" Jeopardy_Contestants = "Jeopardy Contestants" Jeopardy_Contestants_Feature_Class_Output = "C:\\Users\\jvwhit\\Documents\\GitHub\\Python-For-ArcGIS-2017\\Advanced_PythonForArcGIS\\Data\\Answers_Adv\\Illinois.gdb\\JeopardyContestants" Jeopardy_Contestants_Buffer_Output = "C:\\Users\\jvwhit\\Documents\\GitHub\\Python-For-ArcGIS-2017\\Advanced_PythonForArcGIS\\Data\\Answers_Adv\\Illinois.gdb\\JeopardyContestants_Buffer" # Process: Copy Rows arcpy.CopyRows_management(Jeopardy_CSV_File, JeopardyContestants_Table, "") # Process: Make XY Event Layer arcpy.MakeXYEventLayer_management( JeopardyContestants_Table, "lon", "lat", Jeopardy_Contestants, "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]];-400 -400 1000000000;-100000 10000;-100000 10000;8.98315284119522E-09;0.001;0.001;IsHighPrecision", "") # Process: Select arcpy.Select_analysis(Jeopardy_Contestants, Jeopardy_Contestants_Feature_Class_Output, "\"lat\" IS NOT NULL OR \"lon\" IS NOT NULL") # Process: Buffer arcpy.Buffer_analysis(Jeopardy_Contestants_Feature_Class_Output, Jeopardy_Contestants_Buffer_Output, "5 Miles", "FULL",
def join_SFR_out2streams(self, use_arcpy=True): # get model info try: DX, DY, NLAY, NROW, NCOL, i = disutil.read_meta_data(self.DISfile) except: raise IOError("Cannot read MODFLOW DIS file {0}".format( self.DISfile)) print "\naggregating flow information by cellnum..." indata = open(self.SFR_out).readlines() for line in indata[8:]: line = line.strip().split() # Kludge! terminates with blank line (only reads stress per. 1) # need to add support for transient. if len(line) == 0: break r, c = int(line[1]), int(line[2]) cellnum = (r - 1) * NCOL + c seg_rch = "{0} {1}; ".format(line[3], line[4]) flow = 0.5 * (float(line[5]) + float(line[7])) loss = float(line[6]) overland = float(line[8]) stage = float(line[11]) depth = float(line[12]) try: existingflow = self.flow_by_cellnum[cellnum] seg_rch_info = self.seg_rch_by_cellnum[cellnum] except KeyError: existingflow = 0 seg_rch_info = 'segs rchs: ' # determine state if flow == 0: state = 'dry' elif loss > 0: state = 'losing' elif loss < 0: state = 'gaining' else: print 'Stream reach in cell {} has flow, but no interaction with aquifer.'.format( cellnum) self.flow_by_cellnum[cellnum] = existingflow + flow self.seg_rch_by_cellnum[cellnum] = seg_rch_info + seg_rch self.loss_by_cellnum[cellnum] = loss self.state_by_cellnum[cellnum] = state self.overland_by_cellnum[cellnum] = overland self.stage_by_cellnum[cellnum] = stage self.depth_by_cellnum[cellnum] = depth # write to temporary output file ofp = open(os.path.join(self.outpath, 'temp.csv'), 'w') ofp.write( '{},row,column,seg_reach,flow,loss,overland,state,stage,depth\n'. format(self.node_num_attribute)) for cn in self.flow_by_cellnum.keys(): ofp.write('{0},{1},{2},"{3}",{4:.6e},{5},{6},{7},{8},{9}\n'.format( cn, 1, 1, self.seg_rch_by_cellnum[cn], self.flow_by_cellnum[cn], self.loss_by_cellnum[cn], self.overland_by_cellnum[cn], self.state_by_cellnum[cn], self.stage_by_cellnum[cn], self.depth_by_cellnum[cn])) ofp.close() outfile = os.path.join(self.outpath, "{0}.shp".format(self.SFR_out[:-4])) if use_arcpy: try: import arcpy import SFR_arcpy except: print 'module arcpy not found!' # make feature/table layers arcpy.env.workspace = self.outpath arcpy.env.overwriteOutput = True arcpy.CopyFeatures_management( self.streams_shp, self.streams_shp[:-4] + '_backup.shp') arcpy.MakeFeatureLayer_management( self.streams_shp[:-4] + '_backup.shp', "streams") arcpy.CopyRows_management(os.path.join(self.outpath, 'temp.csv'), os.path.join(self.outpath, 'temp.dbf')) # drop all fields except for cellnum from stream linework Fields = arcpy.ListFields("streams") Fields = [ f.name for f in Fields if f.name not in ["FID", "Shape", self.node_num_attribute] ] if len(Fields) > 0: arcpy.DeleteField_management("streams", Fields) SFR_arcpy.general_join(outfile, "streams", self.node_num_attribute, "temp.dbf", self.node_num_attribute, keep_common=True) else: import sys sys.path.append('../../GIS_utils') try: import GISops except: print 'GIS_utils.GISops not found!' GISops.join_csv2shp(self.streams_shp, self.node_num_attribute, os.path.join(self.outpath, 'temp.csv'), self.node_num_attribute, outfile, how='inner')
def main(*argv): """ main driver of program """ try: if os.path.split(sys.executable)[1] == 'ArcGISPro.exe': # Expected Parameters in_new = argv[0] in_old = argv[1] unique = argv[2] out_db = argv[3] else: # Expected Parameters in_new = argv[0] in_old = argv[1] unique = argv[2] out_db = argv[3] t_flag = argv[4] if t_flag.lower() not in ['fc', 'fs', 'sdf']: raise Exception('Input Type Not In Accepted Options: fc | fs | sdf') # Local Variables out_table = os.path.join(out_db, "InformationTable") out_fc = os.path.join(out_db, "changed_features") change_csv = os.path.join(arcpy.env.scratchFolder, "changes.csv") change_table = os.path.join(out_db, "change_table") # Remove Existing Files for target in [out_fc, out_table]: if arcpy.Exists(target): arcpy.Delete_management(target) # Create Information Table (Overview of Differences) if t_flag!= 'sdf': build_information_table(out_db, in_new, in_old) # Create SpatialDataFrame Objects old_sdf = arcgis.features.SpatialDataFrame.from_featureclass(in_old) new_sdf = arcgis.features.SpatialDataFrame.from_featureclass(in_new) else: old_sdf=in_old new_sdf=in_new # Remove Duplicate Values in old_sdf/new_sdf for sdf_set in [[old_sdf, in_old], [new_sdf, in_new]]: handle_duplicates(sdf_set, unique, t_flag) # Find Adds, Deletes and Matching Values merged = pd.merge(old_sdf, new_sdf, on=[unique], how='outer', indicator=True) adds = merged.loc[merged['_merge'] == 'right_only'] deletes = merged.loc[merged['_merge'] == 'left_only'] if len(adds) > 0: q = new_sdf[unique].isin(adds[unique].tolist()) new_sdf[q].to_featureclass( out_location=out_db, out_name="added_features", overwrite=True, skip_invalid=True ) if len(deletes) > 0: q = old_sdf[unique].isin(deletes[unique].tolist()) old_sdf[q].to_featureclass( out_location=out_db, out_name="deleted_features", overwrite=True, skip_invalid=True ) # Assess Changed Features fields = [field for field in old_sdf.columns.tolist() if field in new_sdf.columns.tolist()] if 'SHAPE' in fields: fields.remove("SHAPE") old_uids = set(old_sdf[unique].unique().tolist()) new_uids = set(new_sdf[unique].unique().tolist()) common_uids = list(new_uids.intersection(old_uids)) cq = new_sdf[unique].isin(common_uids) cq1 = old_sdf[unique].isin(common_uids) old_sdf = old_sdf[cq1].copy() new_sdf = new_sdf[cq].copy() new_sdf.index = new_sdf[unique] old_sdf.index = old_sdf[unique] old_sdf.sort_index(inplace=True) new_sdf.sort_index(inplace=True) ne_stacked = (old_sdf[fields] != new_sdf[fields]).stack() changed = ne_stacked[ne_stacked] changed.index.names = [unique, 'col'] difference_locations = np.where(old_sdf[fields] != new_sdf[fields]) changed_from = new_sdf[fields].values[difference_locations] changed_to = old_sdf[fields].values[difference_locations] df_new = pd.DataFrame({'from_val': changed_from, 'to_val': changed_to}, index=changed.index) df_new.reset_index(level=['col'],inplace=True) q3 = df_new['from_val'].isnull() & df_new['to_val'].isnull() df_new[~q3].to_csv(change_csv) joined_sdf = arcgis.features.SpatialDataFrame.merge(new_sdf, df_new[~q3], right_index=True, left_index=True) q4 = joined_sdf['from_val'].isnull() & joined_sdf['to_val'].isnull() stripped_sdf = joined_sdf[~q4] stripped_sdf.drop('from_val', axis=1, inplace=True) stripped_sdf.drop('to_val', axis=1, inplace=True) stripped_sdf.drop('col', axis=1, inplace=True) stripped_sdf['Edit Count'] = stripped_sdf.groupby([unique]).size() stripped_sdf.drop_duplicates(subset=unique, keep='last', inplace=True) stripped_sdf.to_featureclass( out_location=out_db, out_name="changed_features", overwrite=True, skip_invalid=True ) arcpy.CopyRows_management(change_csv, change_table) arcpy.AddMessage('Done.') except arcpy.ExecuteError: line, filename, synerror = trace() arcpy.AddError("error on line: %s" % line) arcpy.AddError("error in file name: %s" % filename) arcpy.AddError("with error message: %s" % synerror) arcpy.AddError("ArcPy Error Message: %s" % arcpy.GetMessages(2)) except FunctionError as f_e: messages = f_e.args[0] arcpy.AddError("error in function: %s" % messages["function"]) arcpy.AddError("error on line: %s" % messages["line"]) arcpy.AddError("error in file name: %s" % messages["filename"]) arcpy.AddError("with error message: %s" % messages["synerror"]) arcpy.AddError("ArcPy Error Message: %s" % messages["arc"]) except: line, filename, synerror = trace() arcpy.AddError("error on line: %s" % line) arcpy.AddError("error in file name: %s" % filename) arcpy.AddError("with error message: %s" % synerror)
sqlClause = "(year = 2013 AND hour IN (16,17)) AND day IN (7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119,126,133,140,147,154,161,168,175,182,189,196,203,210,217,224,231,238,245,252,259,266,273,280,287,294,301,308,315,322,329,336,343,350,357,364)" whereClause = "(CycleEvents.edge_id = AucklandStravaMetro_Edges_NZTM.edge_id)" #todo: make query Layer print 'make Query Layer' listTables = [] listTables.append(tbl) arcpy.MakeQueryTable_management(in_table=listTables, out_table="auckland_edges_ride_data", in_key_field_option="ADD_VIRTUAL_KEY_FIELD") #copy Query Table Locally print 'Copy Query Tables Locally to Cycle Events' if arcpy.Exists("CycleEvents"): arcpy.Delete_management("CycleEvents") arcpy.CopyRows_management("auckland_edges_ride_data", "CycleEvents") flds = [] flds.append("edge_id") arcpy.AddIndex_management(in_table="CycleEvents", fields=flds, index_name="EdgeIdIdx") #many To One Join #print "start Many To One Join" #listTables = ["CycleEvents", fc] #arcpy.MakeQueryTable_management(in_table = listTables, out_table = "temp1", in_key_field_option = "ADD_VIRTUAL_KEY_FIELD", where_clause = whereClause) #print 'Copy Query Tables Locally to All Cycle Event Features' #if arcpy.Exists("AllCycleEvents"): # print "deleting AllCycleEvents..." # arcpy.Delete_management("AllCycleEvents") #print "copying AllCycleEvents..."
#Output variable patchTable = sys.argv[ -2] # The last input is a boolean in the tool that allows for resetting values ##--FUNCTIONS-- def msg(txt): print txt arcpy.AddMessage(txt) return ##--PROCESSES-- #Create a table from the CSV file msg("Creating attribute table") attributeTbl = arcpy.CopyRows_management(inputCSV, "in_memory/attributeTbl") #Get field names for everything but the patch id field (i.e. the first field) fldNames = [] for f in arcpy.ListFields(attributeTbl)[2:]: fldNames.append(str(f.name)) #Calculate summary stats for each field msg("Analysing values to compute normalizations") statFlds = [] for f in fldNames: msg("...%s" % f) statFlds.append([f, "MIN"]) statFlds.append([f, "MAX"]) statFlds.append([f, "RANGE"]) sumTbl = arcpy.Statistics_analysis(attributeTbl, "in_memory/sumTbl", statFlds)
def main(projPath, in_network, landuse, CrossingLow, CrossingHigh, AdjLow, AdjHigh, CanalLow, CanalHigh, RRLow, RRHigh, out_name): scratch = 'in_memory' arcpy.env.overwriteOutput = True # CrossingLow = 10 # CrossingHigh = 100 # AdjLow = 10 # AdjHigh = 100 # CanalLow = 50 # CanalHigh = 200 # RRLow = 30 # RRHigh = 100 # function to calculate slope-intercept equation based on user inputs def slopeInt(lowValue, highValue): x1 = lowValue y1 = 0.99 x2 = highValue y2 = 0.01 m = (y2 - y1) / (x2 - x1) # calculate slope b = y1 - (m * x1) # calculate y-intercept return [m, b] if out_name.endswith('.shp'): out_network = os.path.join(os.path.dirname(in_network), out_name) else: out_network = os.path.join(os.path.dirname(in_network), out_name + ".shp") arcpy.CopyFeatures_management(in_network, out_network) # check for oPC_Score field and delete if already exists fields = [f.name for f in arcpy.ListFields(out_network)] if "oPC_Score" in fields: arcpy.DeleteField_management(out_network, "oPC_Score") # create segid array for joining output segid_np = arcpy.da.FeatureClassToNumPyArray(out_network, "ReachID") segid_array = np.asarray(segid_np, np.int64) # road crossing conflict if "iPC_RoadX" in fields: roadx_array = arcpy.da.FeatureClassToNumPyArray( out_network, "iPC_RoadX") roadx = np.asarray(roadx_array, np.float64) roadx_pc = np.empty_like(roadx) m = slopeInt(CrossingLow, CrossingHigh)[0] b = slopeInt(CrossingLow, CrossingHigh)[1] for i in range(len(roadx)): if roadx[i] >= 0 and roadx[i] <= CrossingLow: roadx_pc[i] = 0.99 elif roadx[i] > CrossingLow and roadx[i] <= CrossingHigh: roadx_pc[i] = m * roadx[i] + b elif roadx[i] > CrossingHigh: roadx_pc[i] = 0.01 else: roadx_pc[i] = 0.01 del roadx_array, roadx, m, b else: roadx_pc = np.zeros_like(segid_array) # road adjacent conflict if "iPC_RoadAd" in fields: roadad_array = arcpy.da.FeatureClassToNumPyArray( out_network, "iPC_RoadAd") roadad = np.asarray(roadad_array, np.float64) #roadad_pc = np.zeros_like(roadad) roadad_pc = np.empty_like(roadad) m = slopeInt(AdjLow, AdjHigh)[0] b = slopeInt(AdjLow, AdjHigh)[1] for i in range(len(roadad)): if roadad[i] >= 0 and roadad[i] <= AdjLow: roadad_pc[i] = 0.99 elif roadad[i] > AdjLow and roadad[i] <= AdjHigh: roadad_pc[i] = m * roadad[i] + b elif roadad[i] > AdjHigh: roadad_pc[i] = 0.01 else: roadad_pc[i] = 0.01 del roadad_array, roadad, m, b else: roadad_pc = np.zeros_like(segid_array) # canal conflict if "iPC_Canal" in fields: canal_array = arcpy.da.FeatureClassToNumPyArray( out_network, "iPC_Canal") canal = np.asarray(canal_array, np.float64) #canal_pc = np.zeros_like(canal) canal_pc = np.empty_like(canal) m = slopeInt(CanalLow, CanalHigh)[0] b = slopeInt(CanalLow, CanalHigh)[1] for i in range(len(canal)): if canal[i] >= 0 and canal[i] <= CanalLow: canal_pc[i] = 0.99 elif canal[i] > CanalLow and canal[i] <= CanalHigh: canal_pc[i] = m * canal[i] + b elif canal[i] > CanalHigh: canal_pc[i] = 0.01 else: canal_pc[i] = 0.01 del canal_array, canal, m, b else: canal_pc = np.zeros_like(segid_array) # railroad conflict if "iPC_RR" in fields: rr_array = arcpy.da.FeatureClassToNumPyArray(out_network, "iPC_RR") rr = np.asarray(rr_array, np.float64) #rr_pc = np.zeros_like(rr) rr_pc = np.empty_like(rr) m = slopeInt(RRLow, RRHigh)[0] b = slopeInt(RRLow, RRHigh)[1] for i in range(len(rr)): if rr[i] >= 0 and rr[i] <= RRLow: rr_pc[i] = 0.99 elif rr[i] > RRLow and rr[i] <= RRHigh: rr_pc[i] = m * rr[i] + b elif rr[i] > RRHigh: rr_pc[i] = 0.01 else: rr_pc[i] = 0.01 del rr_array, rr, m, b else: rr_pc = np.zeros_like(segid_array) # landuse conflict if "iPC_LU" in fields: lu_array = arcpy.da.FeatureClassToNumPyArray(out_network, "iPC_LU") lu = np.asarray(lu_array, np.float64) lu_pc = np.empty_like(lu) # for i in range(len(lu)): # if lu[i] >= 2: # lu_pc[i] = 0.75 # elif lu[i] >= 1.25 and lu[i] < 2: # lu_pc[i] = 0.5 # elif lu[i] < 1.25: # lu_pc[i] = 0.01 # else: # lu_pc[i] = 0.01 for i in range(len(lu)): if lu[i] >= 1.0: lu_pc[i] = 0.99 elif lu[i] >= 0.66 and lu[i] < 1.0: lu_pc[i] = 0.75 elif lu[i] >= 0.33 and lu[i] < 0.66: lu_pc[i] = 0.5 elif lu[i] > 0 and lu[i] < 0.33: lu_pc[i] = 0.25 else: lu_pc[i] = 0.01 else: lu_pc = np.zeros_like(segid_array) # get max of all individual conflict potential scores # this is our conflict potential output oPC_Score = np.fmax( roadx_pc, np.fmax(roadad_pc, np.fmax(canal_pc, np.fmax(rr_pc, lu_pc)))) # save the output text file columns = np.column_stack((segid_array, oPC_Score)) out_table = os.path.dirname(out_network) + "/oPC_Score_Table.txt" np.savetxt(out_table, columns, delimiter=",", header="ReachID, oPC_Score", comments="") opc_score_table = scratch + "/opc_score_table" arcpy.CopyRows_management(out_table, opc_score_table) # join the output to the flowline network # create empty dictionary to hold input table field values tblDict = {} # add values to dictionary with arcpy.da.SearchCursor(opc_score_table, ['ReachID', 'oPC_Score']) as cursor: for row in cursor: tblDict[row[0]] = row[1] # populate flowline network out field arcpy.AddField_management(out_network, 'oPC_Score', 'DOUBLE') with arcpy.da.UpdateCursor(out_network, ['ReachID', 'oPC_Score']) as cursor: for row in cursor: try: aKey = row[0] row[1] = tblDict[aKey] cursor.updateRow(row) except: pass tblDict.clear() arcpy.Delete_management(out_table) arcpy.Delete_management(opc_score_table) addxmloutput(projPath, in_network, out_network)
def add_to_geodatabase(input_items, out_gdb, is_fds): """Adds items to a geodatabase.""" added = 0 skipped = 0 errors = 0 global processed_count global layer_name global existing_fields global new_fields global field_values for ds, out_name in input_items.iteritems(): try: # ----------------------------------------------- # If the item is a service layer, process and continue. # ----------------------------------------------- if ds.startswith('http'): try: service_layer = task_utils.ServiceLayer(ds) arcpy.env.overwriteOutput = True oid_groups = service_layer.object_ids out_features = None g = 0. group_cnt = service_layer.object_ids_cnt for group in oid_groups: g += 1 group = [oid for oid in group if oid] where = '{0} IN {1}'.format(service_layer.oid_field_name, tuple(group)) url = ds + "/query?where={}&outFields={}&returnGeometry=true&geometryType=esriGeometryPolygon&f=json".format(where, '*') feature_set = arcpy.FeatureSet() feature_set.load(url) if not out_features: out_features = arcpy.CopyFeatures_management(feature_set, task_utils.create_unique_name(out_name, out_gdb)) else: features = arcpy.CopyFeatures_management(feature_set, task_utils.create_unique_name(out_name, out_gdb)) arcpy.Append_management(features, out_features, 'NO_TEST') try: arcpy.Delete_management(features) except arcpy.ExecuteError: pass status_writer.send_percent(float(g) / group_cnt * 100, '', 'add_to_geodatabase') processed_count += 1. added += 1 status_writer.send_percent(processed_count / result_count, _('Added: {0}').format(ds), 'add_to_geodatabase') continue except Exception as ex: status_writer.send_state(status.STAT_WARNING, str(ex)) errors_reasons[ds] = ex.message errors += 1 continue # ------------------------------ # Is the input a mxd data frame. # ------------------------------ map_frame_name = task_utils.get_data_frame_name(ds) if map_frame_name: ds = ds.split('|')[0].strip() # ------------------------------- # Is the input a geometry feature # ------------------------------- if isinstance(out_name, list): increment = task_utils.get_increment(result_count) for row in out_name: try: name = os.path.join(out_gdb, arcpy.ValidateTableName(ds, out_gdb)) # Create the geometry if it exists. geom = None try: geo_json = row['[geo]'] geom = arcpy.AsShape(geo_json) row.pop('[geo]') except KeyError: pass if geom: if not arcpy.Exists(name): if arcpy.env.outputCoordinateSystem: arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper()) else: arcpy.env.outputCoordinateSystem = 4326 arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper()) layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer_{0}'.format(os.path.basename(name))) existing_fields = [f.name for f in arcpy.ListFields(layer_name)] new_fields = [] field_values = [] for field, value in row.iteritems(): valid_field = arcpy.ValidateFieldName(field, out_gdb) new_fields.append(valid_field) field_values.append(value) arcpy.AddField_management(layer_name, valid_field, 'TEXT') else: if not geom.type.upper() == arcpy.Describe(name).shapeType.upper(): name = arcpy.CreateUniqueName(os.path.basename(name), out_gdb) if arcpy.env.outputCoordinateSystem: arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper()) else: arcpy.env.outputCoordinateSystem = 4326 arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper()) layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer_{0}'.format(os.path.basename(name))) existing_fields = [f.name for f in arcpy.ListFields(layer_name)] new_fields = [] field_values = [] for field, value in row.iteritems(): valid_field = arcpy.ValidateFieldName(field, out_gdb) new_fields.append(valid_field) field_values.append(value) if valid_field not in existing_fields: arcpy.AddField_management(layer_name, valid_field, 'TEXT') else: if not arcpy.Exists(name): arcpy.CreateTable_management(out_gdb, os.path.basename(name)) view_name = arcpy.MakeTableView_management(name, 'tableview') existing_fields = [f.name for f in arcpy.ListFields(view_name)] new_fields = [] field_values = [] for field, value in row.iteritems(): valid_field = arcpy.ValidateFieldName(field, out_gdb) new_fields.append(valid_field) field_values.append(value) if valid_field not in existing_fields: arcpy.AddField_management(view_name, valid_field, 'TEXT') if geom: with arcpy.da.InsertCursor(layer_name, ["SHAPE@"] + new_fields) as icur: icur.insertRow([geom] + field_values) else: with arcpy.da.InsertCursor(view_name, new_fields) as icur: icur.insertRow(field_values) processed_count += 1 if (processed_count % increment) == 0: status_writer.send_percent(float(processed_count) / result_count, _('Added: {0}').format(row['name']), 'add_to_geodatabase') added += 1 continue except Exception as ex: processed_count += 1 errors += 1 errors_reasons[name] = ex.message continue continue # ----------------------------- # Check the data type and clip. # ----------------------------- dsc = arcpy.Describe(ds) if dsc.dataType == 'FeatureClass': if out_name == '': arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(dsc.name, out_gdb)) else: arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(out_name, out_gdb)) elif dsc.dataType == 'ShapeFile': if out_name == '': arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(dsc.name[:-4], out_gdb)) else: arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(out_name, out_gdb)) elif dsc.dataType == 'FeatureDataset': if not is_fds: fds_name = os.path.basename(task_utils.create_unique_name(dsc.name, out_gdb)) fds = arcpy.CreateFeatureDataset_management(out_gdb, fds_name).getOutput(0) else: fds = out_gdb arcpy.env.workspace = dsc.catalogPath for fc in arcpy.ListFeatureClasses(): name = os.path.basename(task_utils.create_unique_name(fc, out_gdb)) arcpy.CopyFeatures_management(fc, os.path.join(fds, name)) arcpy.env.workspace = out_gdb elif dsc.dataType == 'RasterDataset': if is_fds: out_gdb = os.path.dirname(out_gdb) if out_name == '': arcpy.CopyRaster_management(ds, task_utils.create_unique_name(dsc.name, out_gdb)) else: arcpy.CopyRaster_management(ds, task_utils.create_unique_name(out_name, out_gdb)) elif dsc.dataType == 'RasterCatalog': if is_fds: out_gdb = os.path.dirname(out_gdb) if out_name == '': arcpy.CopyRasterCatalogItems_management(ds, task_utils.create_unique_name(dsc.name, out_gdb)) else: arcpy.CopyRasterCatalogItems_management(ds, task_utils.create_unique_name(out_name, out_gdb)) elif dsc.dataType == 'Layer': layer_from_file = arcpy.mapping.Layer(dsc.catalogPath) layers = arcpy.mapping.ListLayers(layer_from_file) for layer in layers: if out_name == '': name = task_utils.create_unique_name(layer.name, out_gdb) else: name = task_utils.create_unique_name(out_name, out_gdb) if layer.isFeatureLayer: arcpy.CopyFeatures_management(layer.dataSource, name) elif layer.isRasterLayer: if is_fds: name = os.path.dirname(name) arcpy.CopyRaster_management(layer.dataSource, name) elif dsc.dataType == 'CadDrawingDataset': arcpy.env.workspace = dsc.catalogPath cad_wks_name = os.path.splitext(dsc.name)[0] for cad_fc in arcpy.ListFeatureClasses(): arcpy.CopyFeatures_management( cad_fc, task_utils.create_unique_name('{0}_{1}'.format(cad_wks_name, cad_fc), out_gdb) ) arcpy.env.workspace = out_gdb elif dsc.dataType == 'File': if dsc.catalogPath.endswith('.kml') or dsc.catalogPath.endswith('.kmz'): name = os.path.splitext(dsc.name)[0] temp_dir = tempfile.mkdtemp() kml_layer = arcpy.KMLToLayer_conversion(dsc.catalogPath, temp_dir, name) group_layer = arcpy.mapping.Layer(os.path.join(temp_dir, '{}.lyr'.format(name))) for layer in arcpy.mapping.ListLayers(group_layer): if layer.isFeatureLayer: arcpy.CopyFeatures_management(layer, task_utils.create_unique_name(layer, out_gdb)) elif layer.isRasterLayer: if is_fds: out_gdb = os.path.dirname(out_gdb) arcpy.CopyRaster_management(layer, task_utils.create_unique_name(layer, out_gdb)) # Clean up temp KML results. arcpy.Delete_management(os.path.join(temp_dir, '{}.lyr'.format(name))) arcpy.Delete_management(kml_layer) else: processed_count += 1 status_writer.send_percent(processed_count / result_count, _('Invalid input type: {0}').format(dsc.name), 'add_to_geodatabase') skipped += 1 skipped_reasons[ds] = _('Invalid input type: {0}').format(dsc.dataType) continue elif dsc.dataType == 'MapDocument': mxd = arcpy.mapping.MapDocument(dsc.catalogPath) if map_frame_name: df = arcpy.mapping.ListDataFrames(mxd, map_frame_name)[0] layers = arcpy.mapping.ListLayers(mxd, data_frame=df) else: layers = arcpy.mapping.ListLayers(mxd) for layer in layers: if layer.isFeatureLayer: arcpy.CopyFeatures_management(layer.dataSource, task_utils.create_unique_name(layer.name, out_gdb)) elif layer.isRasterLayer: if is_fds: out_gdb = os.path.dirname(out_gdb) arcpy.CopyRaster_management(layer.dataSource, task_utils.create_unique_name(layer.name, out_gdb)) table_views = arcpy.mapping.ListTableViews(mxd) if is_fds: out_gdb = os.path.dirname(out_gdb) for table_view in table_views: arcpy.CopyRows_management(table_view.dataSource, task_utils.create_unique_name(table_view.name, out_gdb)) out_gdb = arcpy.env.workspace elif dsc.dataType.find('Table') > 0: if is_fds: out_gdb = os.path.dirname(out_gdb) if out_name == '': arcpy.CopyRows_management(ds, task_utils.create_unique_name(dsc.name, out_gdb)) else: arcpy.CopyRows_management(ds, task_utils.create_unique_name(out_name, out_gdb)) else: # Try to copy any other types such as topologies, network datasets, etc. if is_fds: out_gdb = os.path.dirname(out_gdb) arcpy.Copy_management(ds, task_utils.create_unique_name(dsc.name, out_gdb)) out_gdb = arcpy.env.workspace processed_count += 1. status_writer.send_percent(processed_count / result_count, _('Added: {0}').format(ds), 'add_to_geodatabase') status_writer.send_status(_('Added: {0}').format(ds)) added += 1 # Continue if an error. Process as many as possible. except Exception as ex: processed_count += 1 status_writer.send_percent(processed_count / result_count, _('Skipped: {0}').format(ds), 'add_to_geodatabase') status_writer.send_status(_('FAIL: {0}').format(repr(ex))) errors_reasons[ds] = repr(ex) errors += 1 continue return added, errors, skipped
out_feature_class=os.path.join( temp_fgdb, "sample_points"))[0] # Update timezones arcpy.AddMessage("Changing Dates and Times from UTC to NZ") fields = ['SampleDate'] with arcpy.da.UpdateCursor(sample_fc, fields) as cursor: for row in cursor: if row[0]: row[0] = changeTimeZone(row[0]) cursor.updateRow(row) # Download records arcpy.AddMessage("Copying Disorder Records") disorder_rows = arcpy.CopyRows_management(in_rows=in_hfs_rel_rows, out_table=os.path.join( temp_fgdb, "disorder_records"))[0] # Export XML arcpy.AddMessage("Exporting XML") sample_fields = [ 'GlobalID', 'FormID', 'Owner', 'Location', 'Stand', 'BioRegion', 'SiteType', 'SampleDate', 'Inspector', 'HostSpec', 'EstabYear', 'Treatment', 'Diam', 'Height', 'InspType', 'Comments', 'SHAPE@X', 'SHAPE@Y', 'Err1' ] disorder_fields = [ 'Sample_GUID', 'DisorderDescription', 'DisorderAgentName', 'DisorderAspect', 'DisorderTerrain', 'DisorderPosition', 'DisorderType',
####################################################################################################################### myLogPrint("\n\n", myLogDatei) myLogPrint( "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", myLogDatei) myLogPrint(" Image Catalog erstellen", myLogDatei) arcpy.AddMessage("Image Catalog erstellen") myLogPrint( "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", myLogDatei) if doIMAGECATALOG == 1: # Kopieren des landesweiten Image Catalogs arcpy.CopyRows_management(IMAGE_CATALOG_ORIG, IMAGE_CATALOG_AOI) arcpy.AddField_management(IMAGE_CATALOG_AOI, "TMP", "SHORT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(IMAGE_CATALOG_AOI, "TMP", "0", "PYTHON_9.3", "") fields01 = ['OBJECT_ID', 'KB'] with arcpy.da.SearchCursor(BS_DOB_AOI, fields01) as cursor01: for row01 in cursor01: ORDNER = row01[1] BS_NR = (str(row01[0])[0:-2]) BS_NR_01 = (str(row01[0])[:-6]) BS_NR_02 = (str(row01[0])[5:-2])
def main(in_network, pt_type, ex_type, scratch): arcpy.env.overwriteOutput = True network_fields = [f.name for f in arcpy.ListFields(in_network)] # fix any values outside of fis range if pt_type == "true": # delete oVC_PT field if exists if "oVC_PT" in network_fields: arcpy.DeleteField_management(in_network, "oVC_PT") cursor = arcpy.da.UpdateCursor(in_network, ["iVeg_100PT", "iVeg_30PT"]) for row in cursor: if row[0] < 0: row[0] = 0 elif row[0] > 4: row[0] = 3.9 elif row[1] < 0: row[1] = 0 elif row[1] > 4: row[1] = 3.9 else: pass cursor.updateRow(row) del row del cursor # get arrays for fields of interest riparian_area_a = arcpy.da.FeatureClassToNumPyArray( in_network, "iVeg_100PT") streamside_a = arcpy.da.FeatureClassToNumPyArray( in_network, "iVeg_30PT") riparian_array = np.asarray(riparian_area_a, np.float64) streamside_array = np.asarray(streamside_a, np.float64) del riparian_area_a, streamside_a # set up input and output ranges riparian = ctrl.Antecedent(np.arange(0, 4, 0.04), 'input1') streamside = ctrl.Antecedent(np.arange(0, 4, 0.04), 'input2') density = ctrl.Consequent(np.arange(0, 45, 0.5), 'result') # membership functions riparian['unsuitable'] = fuzz.trapmf(riparian.universe, [0, 0, 0.1, 1]) riparian['barely'] = fuzz.trimf(riparian.universe, [0.1, 1, 2]) riparian['moderately'] = fuzz.trimf(riparian.universe, [1, 2, 3]) riparian['suitable'] = fuzz.trimf(riparian.universe, [2, 3, 4]) riparian['preferred'] = fuzz.trimf(riparian.universe, [3, 4, 4]) streamside['unsuitable'] = fuzz.trapmf(streamside.universe, [0, 0, 0.1, 1]) streamside['barely'] = fuzz.trimf(streamside.universe, [0.1, 1, 2]) streamside['moderately'] = fuzz.trimf(streamside.universe, [1, 2, 3]) streamside['suitable'] = fuzz.trimf(streamside.universe, [2, 3, 4]) streamside['preferred'] = fuzz.trimf(streamside.universe, [3, 4, 4]) density['none'] = fuzz.trimf(density.universe, [0, 0, 0.1]) density['rare'] = fuzz.trapmf(density.universe, [0, 0.1, 0.5, 1.5]) density['occasional'] = fuzz.trapmf(density.universe, [0.5, 1.5, 4, 8]) density['frequent'] = fuzz.trapmf(density.universe, [4, 8, 12, 25]) density['pervasive'] = fuzz.trapmf(density.universe, [12, 25, 45, 45]) # rules rule1 = ctrl.Rule(riparian['unsuitable'] & streamside['unsuitable'], density['none']) rule2 = ctrl.Rule(riparian['barely'] & streamside['unsuitable'], density['rare']) rule3 = ctrl.Rule(riparian['moderately'] & streamside['unsuitable'], density['occasional']) rule4 = ctrl.Rule(riparian['suitable'] & streamside['unsuitable'], density['occasional']) rule5 = ctrl.Rule(riparian['preferred'] & streamside['unsuitable'], density['occasional']) rule6 = ctrl.Rule(riparian['unsuitable'] & streamside['barely'], density['rare']) rule7 = ctrl.Rule(riparian['barely'] & streamside['barely'], density['rare']) rule8 = ctrl.Rule(riparian['moderately'] & streamside['barely'], density['occasional']) rule9 = ctrl.Rule(riparian['suitable'] & streamside['barely'], density['frequent']) rule10 = ctrl.Rule(riparian['preferred'] & streamside['barely'], density['frequent']) rule11 = ctrl.Rule(riparian['unsuitable'] & streamside['moderately'], density['rare']) rule12 = ctrl.Rule(riparian['barely'] & streamside['moderately'], density['occasional']) rule13 = ctrl.Rule(riparian['moderately'] & streamside['moderately'], density['occasional']) rule14 = ctrl.Rule(riparian['suitable'] & streamside['moderately'], density['frequent']) rule15 = ctrl.Rule(riparian['preferred'] & streamside['moderately'], density['pervasive']) rule16 = ctrl.Rule(riparian['unsuitable'] & streamside['suitable'], density['rare']) rule17 = ctrl.Rule(riparian['barely'] & streamside['suitable'], density['frequent']) rule18 = ctrl.Rule(riparian['moderately'] & streamside['suitable'], density['frequent']) rule19 = ctrl.Rule(riparian['suitable'] & streamside['suitable'], density['frequent']) rule20 = ctrl.Rule(riparian['preferred'] & streamside['suitable'], density['pervasive']) rule21 = ctrl.Rule(riparian['unsuitable'] & streamside['preferred'], density['occasional']) rule22 = ctrl.Rule(riparian['barely'] & streamside['preferred'], density['frequent']) rule23 = ctrl.Rule(riparian['moderately'] & streamside['preferred'], density['frequent']) rule24 = ctrl.Rule(riparian['suitable'] & streamside['preferred'], density['pervasive']) rule25 = ctrl.Rule(riparian['preferred'] & streamside['preferred'], density['pervasive']) # FIS veg_ctrl = ctrl.ControlSystem([ rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19, rule20, rule21, rule22, rule23, rule24, rule25 ]) veg_fis = ctrl.ControlSystemSimulation(veg_ctrl) out = np.zeros(len(riparian_array)) for i in range(len(out)): veg_fis.input['input1'] = riparian_array[i] veg_fis.input['input2'] = streamside_array[i] veg_fis.compute() out[i] = veg_fis.output['result'] # save the output text file then merge to shapefile fid = np.arange(0, len(out), 1) columns = np.column_stack((fid, out)) out_table = os.path.dirname(in_network) + "/oVC_PT_Table.txt" np.savetxt(out_table, columns, delimiter=",", header="FID, oVC_PT", comments="") ovc_table = scratch + "/ovc_pt_table" arcpy.CopyRows_management(out_table, ovc_table) arcpy.JoinField_management(in_network, "FID", ovc_table, "FID", "oVC_PT") arcpy.Delete_management(out_table) del out, fid, columns, out_table, ovc_table elif ex_type == "true": if "oVC_EX" in network_fields: arcpy.DeleteField_management(in_network, "oVC_EX") cursor = arcpy.da.UpdateCursor(in_network, ["iVeg_100EX", "iVeg_30EX"]) for row in cursor: if row[0] < 0: row[0] = 0 elif row[0] > 4: row[0] = 3.9 elif row[1] < 0: row[1] = 0 elif row[1] > 4: row[1] = 3.9 else: pass cursor.updateRow(row) del row del cursor # get arrays for fields of interest riparian_area_a = arcpy.da.FeatureClassToNumPyArray( in_network, "iVeg_100EX") streamside_a = arcpy.da.FeatureClassToNumPyArray( in_network, "iVeg_30EX") riparian_array = np.asarray(riparian_area_a, np.float64) streamside_array = np.asarray(streamside_a, np.float64) del riparian_area_a, streamside_a # set up input and output ranges riparian = ctrl.Antecedent(np.arange(0, 4, 0.04), 'input1') streamside = ctrl.Antecedent(np.arange(0, 4, 0.04), 'input2') density = ctrl.Consequent(np.arange(0, 45, 0.5), 'result') # membership functions riparian['unsuitable'] = fuzz.trapmf(riparian.universe, [0, 0, 0.1, 1]) riparian['barely'] = fuzz.trimf(riparian.universe, [0.1, 1, 2]) riparian['moderately'] = fuzz.trimf(riparian.universe, [1, 2, 3]) riparian['suitable'] = fuzz.trimf(riparian.universe, [2, 3, 4]) riparian['preferred'] = fuzz.trimf(riparian.universe, [3, 4, 4]) streamside['unsuitable'] = fuzz.trapmf(streamside.universe, [0, 0, 0.1, 1]) streamside['barely'] = fuzz.trimf(streamside.universe, [0.1, 1, 2]) streamside['moderately'] = fuzz.trimf(streamside.universe, [1, 2, 3]) streamside['suitable'] = fuzz.trimf(streamside.universe, [2, 3, 4]) streamside['preferred'] = fuzz.trimf(streamside.universe, [3, 4, 4]) density['none'] = fuzz.trimf(density.universe, [0, 0, 0.1]) density['rare'] = fuzz.trapmf(density.universe, [0, 0.1, 0.5, 1.5]) density['occasional'] = fuzz.trapmf(density.universe, [0.5, 1.5, 4, 8]) density['frequent'] = fuzz.trapmf(density.universe, [4, 8, 12, 25]) density['pervasive'] = fuzz.trapmf(density.universe, [12, 25, 45, 45]) # rules rule1 = ctrl.Rule(riparian['unsuitable'] & streamside['unsuitable'], density['none']) rule2 = ctrl.Rule(riparian['barely'] & streamside['unsuitable'], density['rare']) rule3 = ctrl.Rule(riparian['moderately'] & streamside['unsuitable'], density['occasional']) rule4 = ctrl.Rule(riparian['suitable'] & streamside['unsuitable'], density['occasional']) rule5 = ctrl.Rule(riparian['preferred'] & streamside['unsuitable'], density['occasional']) rule6 = ctrl.Rule(riparian['unsuitable'] & streamside['barely'], density['rare']) rule7 = ctrl.Rule(riparian['barely'] & streamside['barely'], density['rare']) rule8 = ctrl.Rule(riparian['moderately'] & streamside['barely'], density['occasional']) rule9 = ctrl.Rule(riparian['suitable'] & streamside['barely'], density['frequent']) rule10 = ctrl.Rule(riparian['preferred'] & streamside['barely'], density['frequent']) rule11 = ctrl.Rule(riparian['unsuitable'] & streamside['moderately'], density['rare']) rule12 = ctrl.Rule(riparian['barely'] & streamside['moderately'], density['occasional']) rule13 = ctrl.Rule(riparian['moderately'] & streamside['moderately'], density['occasional']) rule14 = ctrl.Rule(riparian['suitable'] & streamside['moderately'], density['frequent']) rule15 = ctrl.Rule(riparian['preferred'] & streamside['moderately'], density['pervasive']) rule16 = ctrl.Rule(riparian['unsuitable'] & streamside['suitable'], density['rare']) rule17 = ctrl.Rule(riparian['barely'] & streamside['suitable'], density['frequent']) rule18 = ctrl.Rule(riparian['moderately'] & streamside['suitable'], density['frequent']) rule19 = ctrl.Rule(riparian['suitable'] & streamside['suitable'], density['frequent']) rule20 = ctrl.Rule(riparian['preferred'] & streamside['suitable'], density['pervasive']) rule21 = ctrl.Rule(riparian['unsuitable'] & streamside['preferred'], density['occasional']) rule22 = ctrl.Rule(riparian['barely'] & streamside['preferred'], density['frequent']) rule23 = ctrl.Rule(riparian['moderately'] & streamside['preferred'], density['frequent']) rule24 = ctrl.Rule(riparian['suitable'] & streamside['preferred'], density['pervasive']) rule25 = ctrl.Rule(riparian['preferred'] & streamside['preferred'], density['pervasive']) # FIS veg_ctrl = ctrl.ControlSystem([ rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10, rule11, rule12, rule13, rule14, rule15, rule16, rule17, rule18, rule19, rule20, rule21, rule22, rule23, rule24, rule25 ]) veg_fis = ctrl.ControlSystemSimulation(veg_ctrl) out = np.zeros(len(riparian_array)) for i in range(len(out)): veg_fis.input['input1'] = riparian_array[i] veg_fis.input['input2'] = streamside_array[i] veg_fis.compute() out[i] = veg_fis.output['result'] # save the output text file then merge to shapefile fid = np.arange(0, len(out), 1) columns = np.column_stack((fid, out)) out_table = os.path.dirname(in_network) + "/oVC_EX_Table.txt" np.savetxt(out_table, columns, delimiter=",", header="FID, oVC_EX", comments="") ovc_table = scratch + "/ovc_ex_table" arcpy.CopyRows_management(out_table, ovc_table) arcpy.JoinField_management(in_network, "FID", ovc_table, "FID", "oVC_EX") arcpy.Delete_management(out_table) del out, fid, columns, out_table, ovc_table else: raise Exception("either historic or existing must be selected") return
'ISO3final "ISO3final" true true false 50 Text 0 0 ,First,#,wdpa_flat_1km2_final,ISO3final,-1,-1;AREA_GEO "AREA_GEO" true true false 8 Double 0 0 ,First,#,wdpa_flat_1km2_final,AREA_GEO,-1,-1;ORIG_FID "ORIG_FID" true true false 4 Long 0 0 ,First,#,wdpa_flat_1km2_final,ORIG_FID,-1,-1;nodeID "nodeID" true true false 4 Long 0 0 ,First,#,wdpa_flat_1km2_final,nodeID,-1,-1;Shape_Leng "Shape_Leng" false true true 8 Double 0 0 ,First,#,wdpa_flat_1km2_final,Shape_Length,-1,-1;Shape_Area "Shape_Area" false true true 8 Double 0 0 ,First,#,wdpa_flat_1km2_final,Shape_Area,-1,-1', config_keyword="") print("wdpa_flat_1km2_final exported in Geopackage") # Process: Generate Near Table (edit output name before running) print( "Now generating Near Table. If you want to do it in postgis, kill the script now and execute in docker the script /globes/USERS/GIACOMO/protconn/scripts/exec_generate_near_table_country.sh" ) arcpy.GenerateNearTable_analysis(wdpa_flat_1km2_final, wdpa_flat_1km2_final, All_distances_300km_Nov2019, "300 Kilometers", "NO_LOCATION", "NO_ANGLE", "ALL", "0", "GEODESIC") print("Near Table generated") # Process: Copy Rows arcpy.CopyRows_management(All_distances_300km_Nov2019, outfile_dist) print("Near Table exported in .txt") print('-------------------------------------------------------') endtime = datetime.now() totaltime = endtime - firststarttime print(' ') print('PROCEDURE COMPLETED. Elapsed time: ', totaltime) print( 'If needed, now execute in docker the script "/globes/USERS/GIACOMO/protconn/scripts/gis_proc/exec_generate_near_table_country.sh" ' ) print(' ') sys.exit()
currentOverwriteOutput = env.overwriteOutput env.overwriteOutput = True scratchWS = env.scratchWorkspace if scratchWS == None: scratchWS = r'in_memory' scratchTable = os.path.join(scratchWS, "cc_temp") delete_me.append(scratchTable) # Local variables: intermed = Output_Table # Process: Copy Rows arcpy.CopyRows_management(Input_Table, Output_Table, "") # Process: Add Unique Row ID arcpy.gp.AddUniqueRowID(Output_Table, "JoinID") # Process: Convert Coordinate Notation (GARS) arcpy.AddMessage("Converting & appending GARS ...") arcpy.ConvertCoordinateNotation_management( intermed, scratchTable, X_Field__Longitude__UTM__MGRS__USNG__GARS__GeoRef_, Y_Field__Latitude_, Input_Coordinate_Format, "GARS", "JoinID", Spatial_Reference) arcpy.JoinField_management(intermed, "JoinID", scratchTable, "JoinID", "GARS") # Process: Convert Coordinate Notation (DD) arcpy.AddMessage("Converting & appending Decimal Degrees ...")
arcpy.Statistics_analysis(LU_PLUS_SOILS, RCN_Stats2, "WGT_RCN sum", "") wgtrows = arcpy.SearchCursor(RCN_Stats2) wgtrow = wgtrows.next() wgtRCN = wgtrow.SUM_WGT_RCN AddMsgAndPrint( "\n\tWeighted Average Runoff Curve No. for " + str(wsName) + " is " + str(int(wgtRCN)), 0) del wsArea del rows del row del wgtrows del wgtrow # Export RCN Summary Table arcpy.CopyRows_management(LU_PLUS_SOILS, RCN_TABLE) # Delete un-necessary fields from summary table arcpy.DeleteField_management( RCN_TABLE, "VALUE;COUNT;SOILS;HYD_CODE;HYD_CODE;WGT_RCN") # ------------------------------------------------------------------ Pass results to user watershed AddMsgAndPrint("\nAdding RCN results to " + str(wsName) + "'s attributes", 0) if not len(arcpy.ListFields(watershed, "RCN")) > 0: arcpy.AddField_management(watershed, "RCN", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(watershed, "RCN", "" + str(wgtRCN) + "", "PYTHON") del wgtRCN
def main(in_network, region, basin_elev, basin_long, basin_jan_precip, basin_lat, Qlow_eqtn=None, Q2_eqtn=None): """ if region is None or region == "None": region = 0 else: region = int(region) if Qlow_eqtn == "None": Qlow_eqtn = None if Q2_eqtn == "None": Q2_eqtn = None """ scratch = 'in_memory' arcpy.env.overwriteOutput = True # set basin specific variables ELEV_FT = float(basin_elev) LONGITUDE = float(basin_long) LATITUDE = float(basin_lat) JAN_PRECIP = float(basin_jan_precip) # create segid array for joining output to input network segid_np = arcpy.da.FeatureClassToNumPyArray(in_network, "ReachID") segid = np.asarray(segid_np, np.int64) # create array for input network drainage area ("iGeo_DA") DA_array = arcpy.da.FeatureClassToNumPyArray(in_network, "iGeo_DA") DA = np.asarray(DA_array, np.float32) # convert drainage area (in square kilometers) to square miles # note: this assumes that streamflow equations are in US customary units (e.g., inches, feet) DAsqm = np.zeros_like(DA) DAsqm = DA * 0.3861021585424458 # create Qlow and Q2 Qlow = np.zeros_like(DA) Q2 = np.zeros_like(DA) arcpy.AddMessage("Adding Qlow and Q2 to network...") """ # --regional curve equations for Qlow (baseflow) and Q2 (annual peak streamflow)-- # # # Add in regional curve equations here # # # if Qlow_eqtn is not None: Qlow = eval(Qlow_eqtn) elif region == 101: # example 1 (box elder county) Qlow = 0.019875 * (DAsqm ** 0.6634) * (10 ** (0.6068 * 2.04)) elif region == 102: # example 2 (upper green generic) Qlow = 4.2758 * (DAsqm ** 0.299) elif region == 24: # oregon region 5 Qlow = 0.000133 * (DAsqm ** 1.05) * (15.3 ** 2.1) elif region == 1: #Truckee ELEV_FT = 6027.722 PRECIP_IN = 23.674 Qlow = (10**-7.2182) * (DAsqm**1.013) * (ELEV_FT**01.1236) * (PRECIP_IN**1.4483) else: Qlow = (DAsqm ** 0.2098) + 1 if Q2_eqtn is not None: Q2 = eval(Q2_eqtn) elif region == 101: # example 1 (box elder county) Q2 = 14.5 * DAsqm ** 0.328 elif region == 102: # example 2 (upper green generic) Q2 = 22.2 * (DAsqm ** 0.608) * ((42 - 40) ** 0.1) elif region == 24: # oregon region 5 Q2 = 0.000258 * (DAsqm ** 0.893) * (15.3 ** 3.15) elif region == 1: #Truckee PRECIP_IN = 23.674 Q2 = 0.0865*(DAsqm**0.736)*(PRECIP_IN**1.59) else: Q2 = 14.7 * (DAsqm ** 0.815) """ # set regional regression equations if region is None: region = 0 if Qlow_eqtn is not None: Qlow = eval(Qlow_eqtn) elif float(region) == 0: Qlow = (DAsqm**0.2098) + 1 # default elif float(region) == 21: Qlow = (10**-0.695) * (DAsqm**1.093) # Rocky Mountains elif float(region) == 22: Qlow = (10**-0.324) * (DAsqm**0.885 ) # Central Basin and Northern Plains elif float(region) == 25: Qlow = (10**-0.301) * (DAsqm**1.008) # Overthrust belt elif float(region) == 26: Qlow = (10**-2.277) * (DAsqm**1.308) # High desert else: arcpy.AddMessage( "WARNING: Region is not part of project area. Quitting iHyd script." ) return if Q2_eqtn is not None: Q2 = eval(Q2_eqtn) elif float(region) == 0: Q2 = 14.7 * (DAsqm**0.815) # default elif float(region) == 21: Q2 = 0.313 * (DAsqm**0.866) * (((ELEV_FT - 3000) / 1000)**2.32) * ( (LONGITUDE - 100)**-0.069) # Rocky Mountains elif float(region) == 22: Q2 = 29.9 * (DAsqm**0.475) # Central Basin and Northern Plains elif float(region) == 25: Q2 = 3.07 * (DAsqm**0.869) * (JAN_PRECIP**0.884) # Overthrust belt elif float(region) == 26: Q2 = 22.2 * (DAsqm**0.608) * ((LATITUDE - 40)**-1.24) # High desert else: arcpy.AddMessage( "WARNING: Region is not part of project area. Quitting iHyd script." ) return # save segid, Qlow, Q2 as single table columns = np.column_stack((segid, Qlow, Q2)) tmp_table = os.path.dirname(in_network) + "/ihyd_Q_Table.txt" np.savetxt(tmp_table, columns, delimiter=",", header="ReachID, iHyd_QLow, iHyd_Q2", comments="") ihyd_table = scratch + "/ihyd_table" arcpy.CopyRows_management(tmp_table, ihyd_table) # join Qlow and Q2 output to the flowline network # create empty dictionary to hold input table field values tblDict = {} # add values to dictionary with arcpy.da.SearchCursor(ihyd_table, ['ReachID', "iHyd_QLow", "iHyd_Q2"]) as cursor: for row in cursor: tblDict[row[0]] = [row[1], row[2]] # check for and delete if output fields already included in flowline network remove_existing_output(in_network) # populate flowline network out field arcpy.AddField_management(in_network, "iHyd_QLow", 'DOUBLE') arcpy.AddField_management(in_network, "iHyd_Q2", 'DOUBLE') with arcpy.da.UpdateCursor(in_network, ['ReachID', "iHyd_QLow", "iHyd_Q2"]) as cursor: for row in cursor: try: aKey = row[0] row[1] = tblDict[aKey][0] row[2] = tblDict[aKey][1] cursor.updateRow(row) except: pass tblDict.clear() # delete temporary table arcpy.Delete_management(tmp_table) # check that Q2 is greater than Qlow # if not, re-calculate Q2 as Qlow + 0.001 with arcpy.da.UpdateCursor(in_network, ["iHyd_QLow", "iHyd_Q2"]) as cursor: for row in cursor: if row[1] < row[0]: row[1] = row[0] + 0.001 else: pass cursor.updateRow(row) arcpy.AddMessage("Adding stream power to network...") # calculate Qlow and Q2 stream power # where stream power = density of water (1000 kg/m3) * acceleration due to gravity (9.80665 m/s2) * discharge (m3/s) * channel slope # note: we assume that discharge ("iHyd_QLow", "iHyd_Q2") was calculated in cubic feet per second and handle conversion to cubic # meters per second (e.g., "iHyd_QLow" * 0.028316846592 arcpy.AddField_management(in_network, "iHyd_SPLow", "DOUBLE") arcpy.AddField_management(in_network, "iHyd_SP2", "DOUBLE") with arcpy.da.UpdateCursor( in_network, ["iGeo_Slope", "iHyd_QLow", "iHyd_SPLow", "iHyd_Q2", "iHyd_SP2" ]) as cursor: for row in cursor: if row[0] < 0.001: slope = 0.001 else: slope = row[0] row[2] = (1000 * 9.80665) * slope * (row[1] * 0.028316846592) row[4] = (1000 * 9.80665) * slope * (row[3] * 0.028316846592) cursor.updateRow(row) makeLayers(in_network)
""" Create report file for each metric """ tmpName = city + '_Final_Combo_' + time.strftime('%Y%m%d_%H-%M') reportfileName = reportfileDir + '/' + tmpName + '.txt' reportFile = open(reportfileName, 'w') """ Write out first line of report file """ reportFile.write('Begin with the final tables the EnviroAtlas community.--' + time.strftime('%Y%m%d--%H%M%S') + '--\n') print 'Final Combination Start Time: ' + time.asctime() #------------------------------------------------------------------------- #-------- CREATE FINAL iTREE TABLE --------------------------------------- """ Copy Table to Final """ if arcpy.Exists(iTreeDir + '/' + city + '_iTree') == False: print 'The iTree Table does not exist.' exit arcpy.CopyRows_management(iTreeDir + '/' + city + '_iTree', finalDir + '/' + city + '_iTree') """ Check and/or make MaxTempReduction Fields """ # Current Fields alliTreeFields = [f.name for f in arcpy.ListFields(finalDir + '/' + city + '_iTree')] maxTempField = filter((lambda x: x.lower().startswith("maxtempreduction_")),alliTreeFields) maxTempNightField = filter((lambda x: x.lower().startswith("maxtempreductionnight_")),alliTreeFields) if maxTempField: print('Adding and calculating maxtempreduction and maxtempreductionnight fields...') arcpy.AddField_management(finalDir + '/' + city + '_iTree', 'maxtempreduction') arcpy.AddField_management(finalDir + '/' + city + '_iTree', 'maxtempreductionnight') arcpy.CalculateField_management(finalDir + '/' + city + '_iTree','maxtempreduction', '!' + str(maxTempField[0]) + '!', 'PYTHON_9.3') arcpy.CalculateField_management(finalDir + '/' + city + '_iTree','maxtempreductionnight', '!' + str(maxTempNightField[0]) + '!', 'PYTHON_9.3') else:
if line1.Rank_UGO != line2.Rank_UGO: # At the end of an UGO, set the last point of this UGO as the UGO (line3) length and the first # point of the next UGO as 0 line3 = rows3.next() line1.MEAS = line3.Shape_Length line2.MEAS = 0 rows1.updateRow(line1) rows2.updateRow(line2) n += 1 #/split of the inflection line at inflection points arcpy.AddMessage( " Preparing the split at inflection points of the final inflection line - 7/9" ) PtsForInflLineDisaggregationTABLE = arcpy.CopyRows_management( InflectionPtTABLE, "%ScratchWorkspace%\\PtsForInflLineDisaggregationTABLE") rows1 = arcpy.UpdateCursor(PtsForInflLineDisaggregationTABLE) rows2 = arcpy.UpdateCursor(PtsForInflLineDisaggregationTABLE) line2 = rows2.next() nrows = int(str(arcpy.GetCount_management(PtsForInflLineDisaggregationTABLE))) n = 0 for line1 in rows1: if n >= nrows - 1: rows1.deleteRow(line1) rows1.updateRow(line1) break line2 = rows2.next() if line1.Rank_UGO != line2.Rank_UGO: rows1.deleteRow(line1) rows1.updateRow(line1)
def tableToPolyline(inputTable, inputCoordinateFormat, inputXField, inputYField, outputPolylineFeatures, inputLineField, inputSortField, inputSpatialReference): ''' Converts a table of vertices to one or more polyline features. inputTable - input table, each row is a vertex inputCoordinateFormat - coordinate notation format of input vertices inputXField - field in inputTable for vertex x-coordinate, or full coordinate inputYField - field in inputTable for vertex y-coordinate, or None outputPolylineFeatures - polyline feature class to create inputLineField - field in inputTable to identify separate polylines inputSortField - field in inputTable to sort vertices inputSpatialReference - spatial reference of input coordinates returns polyline feature class inputCoordinateFormat must be one of the following: * DD_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DD_2: Longitude and latitude values are in two separate fields. * DDM_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DDM_2: Longitude and latitude values are in two separate fields. * DMS_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DMS_2: Longitude and latitude values are in two separate fields. * GARS: Global Area Reference System. Based on latitude and longitude, it divides and subdivides the world into cells. * GEOREF: World Geographic Reference System. A grid-based system that divides the world into 15-degree quadrangles and then subdivides into smaller quadrangles. * UTM_ZONES: The letter N or S after the UTM zone number designates only North or South hemisphere. * UTM_BANDS: The letter after the UTM zone number designates one of the 20 latitude bands. N or S does not designate a hemisphere. * USNG: United States National Grid. Almost exactly the same as MGRS but uses North American Datum 1983 (NAD83) as its datum. * MGRS: Military Grid Reference System. Follows the UTM coordinates and divides the world into 6-degree longitude and 20 latitude bands, but MGRS then further subdivides the grid zones into smaller 100,000-meter grids. These 100,000-meter grids are then divided into 10,000-meter, 1,000-meter, 100-meter, 10-meter, and 1-meter grids. ''' try: deleteme = [] joinFieldName = "JoinID" scratch = '%scratchGDB%' if env.scratchWorkspace: scratch = env.scratchWorkspace inputSpatialReference = _checkSpatialRef(inputSpatialReference) copyRows = os.path.join(scratch, "copyRows") arcpy.CopyRows_management(inputTable, copyRows) addUniqueRowID(copyRows, joinFieldName) copyCCN = os.path.join(scratch, "copyCCN") arcpy.ConvertCoordinateNotation_management(copyRows, copyCCN, inputXField, inputYField, inputCoordinateFormat, "DD_NUMERIC", joinFieldName, inputSpatialReference) arcpy.PointsToLine_management(copyCCN, outputPolylineFeatures, inputLineField, inputSortField, "CLOSE") return outputPolylineFeatures except arcpy.ExecuteError: # Get the tool error messages msgs = arcpy.GetMessages() arcpy.AddError(msgs) print(msgs) except: # Get the traceback object tb = sys.exc_info()[2] tbinfo = traceback.format_tb(tb)[0] # Concatenate information together concerning the error into a message string pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(sys.exc_info()[1]) msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages() + "\n" # Return python error messages for use in script tool or Python Window arcpy.AddError(pymsg) arcpy.AddError(msgs) # Print Python error messages for use in Python / Python Window print(pymsg + "\n") print(msgs) finally: if len(deleteme) > 0: # cleanup intermediate datasets if debug == True: arcpy.AddMessage("Removing intermediate datasets...") for i in deleteme: if debug == True: arcpy.AddMessage("Removing: " + str(i)) arcpy.Delete_management(i) if debug == True: arcpy.AddMessage("Done")
def exportrastab(rasdat, out_table): if not Raster(rasdat).hasRAT: print('Create raster attribute table for {}...'.format(rasdat)) arcpy.BuildRasterAttributeTable_management(rasdat) arcpy.CopyRows_management(rasdat, out_table)
def convert(costpath, file_name_1, file_name_2, name_1, name_2): try: arcpy.RasterToPolyline_conversion( costpath, directory + '\polylines\pl_' + file_name_1 + '_' + file_name_2, "ZERO", 10, "SIMPLIFY") distance = 0 with arcpy.da.SearchCursor( directory + '\polylines\pl_' + file_name_1 + '_' + file_name_2 + '.shp', ['SHAPE@LENGTH']) as poly_cursor: for row in poly_cursor: distance += row[0] # sum distance for each polyline segment except arcpy.ExecuteError: error = arcpy.GetMessages(2) str_error = str(error) if str_error.startswith('ERROR 010151'): print( '\nCannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline, but rest of data should be saved properly. Source and destination may be too' 'close to each other.') print( 'Linear distance between source and destination set to zero in output table.' ) print(str(error)) log.write( asctime() + ': Cannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline, but rest of data should be saved properly.\n' + 'Linear distance between source and destination set to zero in output table.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n') distance = 0 else: print( '\nCannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline, but rest of data should be saved properly.' ) print( 'Linear distance between source and destination not calculated.' ) print(str(error)) log.write( asctime() + ': Cannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline, but rest of data should be saved properly.\n' + 'Linear distance between source and destination not calculated.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n') distance = 'NA' except Exception as error: print('\nCannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline.') print('Linear distance between source and destination not calculated.') print(str(error)) log.write( asctime() + ': Cannot convert cost path raster between ' + loc_one_name + ' and ' + loc_two_name + ' to a valid polyline, but rest of data should be saved properly.\n' + 'Linear distance between source and destination not calculated.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n') distance = 0 try: arcpy.AddField_management(costpath, 'Source', 'TEXT') arcpy.AddField_management(costpath, 'Dest', 'TEXT') arcpy.AddField_management(costpath, 'Distance', 'FLOAT') arcpy.CalculateField_management(costpath, 'Source', "'" + name_1 + "'") arcpy.CalculateField_management(costpath, 'Dest', "'" + name_2 + "'") arcpy.CalculateField_management(costpath, 'Distance', distance) arcpy.MakeTableView_management(costpath, 'table') with arcpy.da.SearchCursor( 'table', ['SOURCE', 'DEST', 'PATHCOST', 'DISTANCE', 'STARTROW' ]) as table_cursor: for entry in table_cursor: if entry[4] != 0: in_cursor = arcpy.da.InsertCursor(table, fields) in_cursor.insertRow( (str(entry[0]), str(entry[1]), entry[2], entry[3])) del in_cursor if int_data is True: try: arcpy.CopyRows_management( costpath, directory + r'\tables\tb_' + file_name_1 + '_' + file_name_2 + '.csv') except Exception as error: print('\nFailed to save data for cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in .csv table. See error message for more details.') print( 'Linear distance between source and destination not calculated.' ) print(str(error)) log.write( asctime() + ': Failed to save data for cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in .csv table. See error message for more details.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n') try: costpath.save(directory + r'\costpath\cp_' + file_name_1 + '_' + file_name_2) except Exception as error: str_error = str(error) if str_error.startswith('ERROR 010240'): print('\nCould not save cost path raster cp_' + file_name_1 + '_' + file_name_2 + ', but rest of data should be saved properly.') print( 'Combination of file names for fc one and fc two likely exceeds 13 characters. ' 'See help file for more information.') log.write( asctime() + ': Could not save cost path raster cp_' + file_name_1 + '_' + file_name_2 + ', but rest of data should be saved properly.\n' + 'Combination of file names for fc one and fc two likely exceed 13 characters. ' 'See help file for more information.\n' + str(error) + '\n' + '----------------------------------------------------' '--------------------------------------' + '\n') else: print( '\nCould not save cost path raster cp_' + file_name_1 + '_' + file_name_2 + ', but rest of data should be saved properly. See error message for more details' ) print(str(error)) log.write( asctime() + ': Could not save cost path raster cp_' + file_name_1 + '_' + file_name_2 + ', but rest of data should be saved properly. See error message for more details.\n' + '-------------------------------------------------------' '-----------------------------------' + '\n') except arcpy.ExecuteError: error = arcpy.GetMessages(2) print('\nFailed to properly save data for least cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in master table. Script will continue with next iteration(1).') print(str(error)) log.write( asctime() + ': Failed to properly save data for least cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in master table. Script continued with next iteration.' + '.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n') except Exception as error: print('\nFailed to properly save data for least cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in master table. Script will continue with next iteration(2).') print(str(error)) log.write( asctime() + ': Failed to properly save data for least cost path between ' + loc_one_name + ' and ' + loc_two_name + ' in master table. Script continued with next iteration.' + '.\n' + str(error) + '------------------------------------------------------------------------------------------' + '\n')
for ab in abbr: arcpy.Select_analysis(outWorkspace + '\Clumped_Cluster_{}.shp"'.format(ab), outWorkspace + '\Dispersed_Input_{}.shp"'.format(ab),'"CLUSTER_ID" = -1') for ab in abbr: arcpy.stats.DensityBasedClustering(outWorkspace + '\Dispersed_Input_{}.shp"'.format(ab), outWorkspace + '\Dispersed_Cluster_{}.shp"'.format(ab), "OPTICS", minFeatures2, srcDistance2, "") for ab in abbr: arcpy.Select_analysis(outWorkspace + '\Dispersed_Cluster_{}.shp"'.format(ab), outWorkspace + '\Random_Points{}.shp"'.format(ab),'"CLUSTER_ID" = -1') tableList = arcpy.ListTables for dbaseTable in tableList(): # check if there is a way to only select certain tables - don't need inputs, just outputs if "Random_points" in tableList(): outTable = os.path.join(outWorkspace, os.path.splitext(dbaseTable)[0]) arcpy.CopyRows_management(dbaseTable, outTable.csv) else: print("Table could not be found.") # try excepts: arcgisscripting.ExecuteError: ERROR 110141: The Minimum Number of Features per Cluster is greater than the number of features in the dataset.Failed to execute (DensityBasedClustering). # these files can then be read back in and counted for the results ie. print("************************************************************************") total_random_points = [] total_clumped_clusters = [] total_dispersed_clusters = [] with open(file_path + "random_point_rows.csv","r") as csv_file: # wasn't recognizing file in same folder, had to add file path csv_reader = csv.reader(csv_file, delimiter=',') for lines in csv_reader:
arcpy.env.overwriteOutput = True infilename = arcpy.GetParameterAsText(0) #as CSV infile = arcpy.GetParameter(0) outfile = arcpy.GetParameterAsText(1) #as GDB outname = outfile + '\\AllPoints' csvFile = os.path.basename(infilename) spRef = arcpy.SpatialReference( "NAD 1983 StatePlane Missouri East FIPS 2401 (US Feet)") if arcpy.Exists(outfile) == False: arcpy.AddMessage("Creating GDB...") arcpy.CreateFileGDB_management(os.path.dirname(outfile), os.path.basename(outfile)) arcpy.AddMessage("Copying Rows...") for inputs in infile: arcpy.AddMessage(inputs) if arcpy.Exists(outname) == False: arcpy.CopyRows_management(csvFile, outname) else: arcpy.Append_management(inputs, outfile + '/AllPoints', 'NO_TEST', '', '') arcpy.AddMessage("Making Point Features...") arcpy.MakeXYEventLayer_management(outname, "XCoord", "YCoord", "Temp_Points", spRef, "") arcpy.FeatureClassToFeatureClass_conversion("Temp_Points", outfile, 'STL_CRIME_POINTS') arcpy.Delete_management(outname)
if row[3] is None: #Transfer AADT_avg to AADT_interp row[3] = row[2] cursor.updateRow(row) #For all non-arterial roads that do not already have an AADT value, assign 1000 arcpy.JoinField_management(roadstraffic_avg, 'CUSTOM_ID', 'routes_loc', 'CUSTOM_ID', 'AADT_interp') with arcpy.da.UpdateCursor(roadstraffic_avg, ['ARTDESCRIP','AADT_avg','AADT_interp']) as cursor: for row in cursor: if row[1] is not None: row[2] = row[1] if row[1] is None and row[2] is None and row[0] in ['','Not Designated']: row[2]=1000 cursor.updateRow(row) #Write out individual roads' attributes arcpy.CopyRows_management(roadstraffic_avg, path.join(rootdir, 'results/Seattle_roads.dbf')) ######################################################################################################################## ######################################################################################################################## # CREATE HEATMAPS OF SPEEDLIMIT, AADT, and BING # Use a logarithmic decay function to 'simulate' the pollution spread of various levels of traffic volume, speed, # and congestion ######################################################################################################################## res = arcpy.GetRasterProperties_management(path.join(rootdir,'results/bing/180620_09_30_class_mlc.tif'), 'CELLSIZEX') #SPEED LIMIT arcpy.PolylineToRaster_conversion(roadstraffic_avg, value_field='SPEEDLIMIT', out_rasterdataset='Seattle_spdlm', priority_field='SPEEDLIMIT',cellsize=res) heat_spdlm = FocalStatistics(path.join(gdb,'Seattle_spdlm'), neighborhood=NbrWeight('C:/Mathis/ICSL/stormwater/results/logkernel100.txt'), statistics_type='SUM', ignore_nodata='DATA') #It seems that full paths are needed to make this work heat_spdlm.save('heat_spdlm') heat_spdlm_int = Int(Raster('heat_spdlm')+0.5) #Constantly result in overall python crash?
destination_view = os.path.join(arcpy.env.scratchGDB, 'destination_table_view') print(destination_view) #zones to calculate stats on #inpoly = r"E:/Guyana Priority Areas - Backup/Planning Units/hex_5km_pu_wgs84_102218.shp" inpoly = r"E:/Guyana Priority Areas - Backup/Planning Units/North_Rupununi/nrup_pu_3119_1km_hex_wgs84_ed.shp" print(inpoly) #where to save output files destination_path = r"E:/test/tables" print(destination_path) #list of rasters to calculate statistics on rasters = arcpy.ListRasters("*", "TIF") for raster in rasters: print(raster) destination_raster = os.path.join(destination_path, raster)[:-4] + '.dbf' arcpy.gp.ZonalStatisticsAsTable_sa(inpoly, "PU_ID", raster, destination_raster, "DATA", "SUM") destination_csv = os.path.join(destination_path, raster)[:-4] + '.csv' field_info = arcpy.FieldInfo() for field in arcpy.ListFields(destination_raster): field_info.addField(field.name, field.name, "VISIBLE", "") arcpy.MakeTableView_management(destination_raster, destination_view, "", "", field_info) arcpy.CopyRows_management(destination_view, destination_csv) arcpy.CheckInExtension("Spatial")
def tableToLineOfBearing(inputTable, inputCoordinateFormat, inputXField, inputYField, inputBearingUnits, inputBearingField, inputDistanceUnits, inputDistanceField, outputLineFeatures, inputLineType, inputSpatialReference): ''' Tool method for converting a table of starting points, bearings, and distances to line features. inputTable - input table, each row will be a separate line feature in output inputCoordinateFormat - coordinate notation format of input vertices inputXField - field in inputTable for vertex x-coordinate, or full coordinate inputYField - field in inputTable for vertex y-coordinate, or None inputBearingUnits - inputBearingField - inputDistanceUnits - inputDistanceField - outputLineFeatures - polyline feature class to create inputLineType - inputSpatialReference - spatial reference of input coordinates returns polyline feature class inputCoordinateFormat must be one of the following: * DD_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DD_2: Longitude and latitude values are in two separate fields. * DDM_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DDM_2: Longitude and latitude values are in two separate fields. * DMS_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash. * DMS_2: Longitude and latitude values are in two separate fields. * GARS: Global Area Reference System. Based on latitude and longitude, it divides and subdivides the world into cells. * GEOREF: World Geographic Reference System. A grid-based system that divides the world into 15-degree quadrangles and then subdivides into smaller quadrangles. * UTM_ZONES: The letter N or S after the UTM zone number designates only North or South hemisphere. * UTM_BANDS: The letter after the UTM zone number designates one of the 20 latitude bands. N or S does not designate a hemisphere. * USNG: United States National Grid. Almost exactly the same as MGRS but uses North American Datum 1983 (NAD83) as its datum. * MGRS: Military Grid Reference System. Follows the UTM coordinates and divides the world into 6-degree longitude and 20 latitude bands, but MGRS then further subdivides the grid zones into smaller 100,000-meter grids. These 100,000-meter grids are then divided into 10,000-meter, 1,000-meter, 100-meter, 10-meter, and 1-meter grids. inputBearingUnits must be one of the following: * DEGREES * MILS * RADS * GRAD inputDistanceUnits must be one of the following: * METERS * KILOMETERS * MILES * NAUTICAL_MILES * FEET * US_SURVEY_FEET inputLineType must be one of the following: * GEODESIC: * GREAT_CIRCLE: * RHUMB_LINE: * NORMAL_SECTION: ''' try: env.overwriteOutput = True deleteme = [] joinFieldName = "JoinID" scratch = '%scratchGDB%' if env.scratchWorkspace: scratch = env.scratchWorkspace inputSpatialReference = _checkSpatialRef(inputSpatialReference) copyRows = os.path.join(scratch, "copyRows") arcpy.CopyRows_management(inputTable, copyRows) originalTableFieldNames = _tableFieldNames(inputTable, joinExcludeFields) addUniqueRowID(copyRows, joinFieldName) arcpy.AddMessage("Formatting start point...") copyCCN = os.path.join(scratch, "copyCCN") arcpy.ConvertCoordinateNotation_management(copyRows, copyCCN, inputXField, inputYField, inputCoordinateFormat, "DD_NUMERIC", joinFieldName, inputSpatialReference) arcpy.AddMessage("Creating lines as {0}...".format(inputLineType)) arcpy.BearingDistanceToLine_management( copyCCN, outputLineFeatures, "DDLon", "DDLat", inputDistanceField, inputDistanceUnits, inputBearingField, inputBearingUnits, inputLineType, joinFieldName, inputSpatialReference) #Join original table fields to output arcpy.AddMessage( "Joining fields from input table to output line features...") arcpy.JoinField_management(outputLineFeatures, joinFieldName, copyRows, joinFieldName, originalTableFieldNames) arcpy.DeleteField_management(outputLineFeatures, [joinFieldName]) return outputLineFeatures except arcpy.ExecuteError: # Get the tool error messages msgs = arcpy.GetMessages() arcpy.AddError(msgs) print(msgs) except: # Get the traceback object tb = sys.exc_info()[2] tbinfo = traceback.format_tb(tb)[0] # Concatenate information together concerning the error into a message string pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str( sys.exc_info()[1]) msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages() + "\n" # Return python error messages for use in script tool or Python Window arcpy.AddError(pymsg) arcpy.AddError(msgs) # Print Python error messages for use in Python / Python Window print(pymsg + "\n") print(msgs) finally: if len(deleteme) > 0: # cleanup intermediate datasets if debug == True: arcpy.AddMessage("Removing intermediate datasets...") for i in deleteme: if debug == True: arcpy.AddMessage("Removing: " + str(i)) arcpy.Delete_management(i) if debug == True: arcpy.AddMessage("Done")
file.write(str(time.ctime()) +": dissolved bikes"+ "\n") except Exception as e: print(e) file.write(str(time.ctime()) +": FAILED TO PROCESS bike counts"+ "\n") ################################################################################################ #STEP THREE # GEOPROCESSING: PED AND BIKE FATALITIES # PED # Ped fatalities try: switrs_mvmt_csv = "C:\\ETLs\\TIM\\TIMUpdates\\Helper Files\\switrs_mvmt.csv" switrs_mvmt_codes = "C:\\ETLs\\TIM\\TIMUpdates\\Helper Files\\switrs_mvmt.dbf" arcpy.CopyRows_management (switrs_mvmt_csv, switrs_mvmt_codes) print "SWITRS codes loaded" except: file.write(str(time.ctime()) +": FAILED TO PROCESS ped fatalities - SWITRS codes loading failed"+ "\n") print "SWITRS codes not loaded" try: print "Filtering for ped fatalities..." # Create shapefile: pedestrian level, fatalities only ped_f = "pedcollisions_party_ped_fatal" arcpy.FeatureClassToFeatureClass_conversion (staging_gdb + pedcol_party, staging_gdb, ped_f, """ "party_type" = 'Pedestrian' AND "party_number_killed" <> 0 """) file.write(str(time.ctime()) +": copied FC - ped fatal"+ "\n") print("Success") except Exception as e: print(e) file.write(str(time.ctime()) +": FAILED TO PROCESS ped fatalities - feature class to feature class conversion (ped level fatalities)"+ "\n")