def createOutput(self, outputTable): """Creates Moran's I Step Output Table. INPUTS outputTable (str): path to the output table """ #### Allow Overwrite Output #### ARCPY.env.overwriteOutput = 1 #### Get Output Table Name With Extension if Appropriate #### outputTable, dbf = UTILS.returnTableName(outputTable) #### Set Progressor #### ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84008)) #### Delete Table If Exists #### UTILS.passiveDelete(outputTable) #### Create Table #### outPath, outName = OS.path.split(outputTable) try: DM.CreateTable(outPath, outName) except: ARCPY.AddIDMessage("ERROR", 541) raise SystemExit() #### Add Result Fields #### self.outputFields = [] for field in iaFieldNames: fieldOut = ARCPY.ValidateFieldName(field, outPath) UTILS.addEmptyField(outputTable, fieldOut, "DOUBLE") self.outputFields.append(fieldOut) #### Create Insert Cursor #### try: insert = DA.InsertCursor(outputTable, self.outputFields) except: ARCPY.AddIDMessage("ERROR", 204) raise SystemExit() #### Add Rows to Output Table #### for testIter in xrange(self.nIncrements): insert.insertRow(self.giResults[testIter]) #### Clean Up #### del insert return outputTable, dbf
def outputPMP(type, area, outPath): desc = arcpy.Describe(basin) basinName = desc.baseName pmpPoints = env.scratchGDB + "\\PMP_Points" # Location of 'PMP_Points' feature class which will provide data for output outType = type[:1] outArea = str(int(round(area, 0))) + "sqmi" outFC = outType + "_" + outArea #I don't think I need this..... arcpy.AddMessage("\nCopying PMP_Points feature class to " + outFC + "...") #outFC might be replaced with outpath... dm.Merge( pmpPoints, outPath ) # merge the scratch feature layer(s) of vector grid cells into the outputs arcpy.AddMessage("\nCreating Basin Summary Table...") tableName = type + "_PMP_Basin_Average" + "_" + outArea tablePath = env.scratchGDB + "\\" + tableName dm.CreateTable(env.scratchGDB, tableName) # Create blank table cursor = arcpy.da.InsertCursor( tablePath, "*") # Create Insert cursor and add a blank row to the table cursor.insertRow([0]) del cursor dm.AddField(tablePath, "STORM_TYPE", "TEXT", "", "", 10, "Storm Type") # Create "Storm Type" field dm.CalculateField(tablePath, "STORM_TYPE", "'" + type + "'", "PYTHON_9.3") # populate storm type field i = 0 for field in arcpy.ListFields( pmpPoints, "PMP_*" ): # Add fields for each PMP duration and calculate the basin average fieldName = field.name fieldAve = basinAve( basin, fieldName ) # Calls the basinAve() function - returns the average (weighted or not) dm.AddField(tablePath, fieldName, "DOUBLE", "", 2) # Add duration field dm.CalculateField(tablePath, fieldName, fieldAve, "PYTHON_9.3") # Assigns the basin average i += 1 arcpy.AddMessage("\nSummary table complete.") basAveTables.append(tablePath) return
def lake_from_to(nhd_subregion_gdb, output_table): arcpy.env.workspace = 'in_memory' waterbody0 = os.path.join(nhd_subregion_gdb, 'NHDWaterbody') network = os.path.join(nhd_subregion_gdb, 'Hydrography', 'HYDRO_NET') junctions0 = os.path.join(nhd_subregion_gdb, 'HYDRO_NET_Junctions') # use layers for selections. We will only work with lakes over 1 hectare for this tool. waterbody = DM.MakeFeatureLayer(waterbody0, 'waterbody', where_clause=LAGOS_LAKE_FILTER) num_wbs = int(arcpy.GetCount_management(waterbody).getOutput(0)) junctions = DM.MakeFeatureLayer(junctions0, 'junctions') DM.SelectLayerByLocation(junctions, 'INTERSECT', waterbody, '1 Meters', 'NEW_SELECTION') junctions_1ha = DM.MakeFeatureLayer(junctions, 'junctions_1ha') # insert results into output table DM.CreateTable(os.path.dirname(output_table), os.path.basename(output_table)) DM.AddField(output_table, 'FROM_PERMANENT_ID', 'TEXT', field_length=40) DM.AddField(output_table, 'TO_PERMANENT_ID', 'TEXT', field_length=40) # create a dictionary to hold results in memory results = [] counter = 0 progress = .01 arcpy.AddMessage("Starting network tracing...") with arcpy.da.SearchCursor(waterbody, 'Permanent_Identifier') as cursor: for row in cursor: # set up a progress printer counter += 1 if counter >= float(num_wbs) * progress: progress += .01 arcpy.AddMessage("{}% complete...".format( round(progress * 100), 1)) # select this lake id = row[0] where_clause = """"{0}" = '{1}'""".format('Permanent_Identifier', id) this_waterbody = DM.MakeFeatureLayer(waterbody, 'this_waterbody', where_clause) # select junctions overlapping this lake. only the downstream one matters, rest have no effect DM.SelectLayerByLocation(junctions_1ha, 'INTERSECT', this_waterbody, '1 Meters') count_junctions = int( arcpy.GetCount_management(junctions_1ha).getOutput(0)) if count_junctions == 0: # add a row with no "TO" lake to the results results.append({'FROM': id, 'TO': None}) else: # copy with selection on this_junctions = DM.MakeFeatureLayer(junctions_1ha, 'this_junctions') DM.TraceGeometricNetwork(network, 'downstream', this_junctions, 'TRACE_DOWNSTREAM') # select lakes that intersect the downstream network with a tolerance of 1 meters DM.SelectLayerByLocation(waterbody, 'INTERSECT', 'downstream/NHDFlowline', '1 Meters', 'NEW_SELECTION') # remove this lake DM.SelectLayerByAttribute(waterbody, 'REMOVE_FROM_SELECTION', where_clause) # get the count, if it's 0 then there should be no table entry or something? count_waterbody = int( arcpy.GetCount_management(waterbody).getOutput(0)) # copy those into the table that you're storing stuff in if count_waterbody == 0: # add a row with no "TO" lake to the results results.append({'FROM': id, 'TO': None}) else: # for each ID, how am I getting those to_ids = [ row[0] for row in arcpy.da.SearchCursor( waterbody, 'Permanent_Identifier') ] for to_id in to_ids: result = {'FROM': id, 'TO': to_id} results.append(result) # delete all the intermediates DM.SelectLayerByAttribute(waterbody, 'CLEAR_SELECTION') for item in [this_waterbody, this_junctions, 'downstream']: DM.Delete(item) # insert the results in the table insert_cursor = arcpy.da.InsertCursor( output_table, ['FROM_PERMANENT_ID', 'TO_PERMANENT_ID']) for result in results: insert_cursor.insertRow([result['FROM'], result['TO']]) # delete everything for item in [waterbody, junctions, junctions_1ha, 'in_memory']: DM.Delete(item) arcpy.AddMessage("Completed.")
def createOutput(self, outputTable, displayIt = False): """Creates K-Function Output Table. INPUTS outputTable (str): path to the output table displayIt {bool, False}: create output graph? """ #### Allow Overwrite Output #### ARCPY.env.overwriteOutput = 1 #### Get Output Table Name With Extension if Appropriate #### outputTable, dbf = UTILS.returnTableName(outputTable) #### Set Progressor #### ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84008)) #### Delete Table If Exists #### UTILS.passiveDelete(outputTable) #### Create Table #### outPath, outName = OS.path.split(outputTable) try: DM.CreateTable(outPath, outName) except: ARCPY.AddIDMessage("ERROR", 541) raise SystemExit() #### Add Result Fields #### fn = UTILS.getFieldNames(kOutputFieldNames, outPath) expectedKName, observedKName, diffKName, lowKName, highKName = fn outputFields = [expectedKName, observedKName, diffKName] if self.permutations: outputFields += [lowKName, highKName] for field in outputFields: UTILS.addEmptyField(outputTable, field, "DOUBLE") #### Create Insert Cursor #### try: insert = DA.InsertCursor(outputTable, outputFields) except: ARCPY.AddIDMessage("ERROR", 204) raise SystemExit() #### Add Rows to Output Table #### for testIter in xrange(self.nIncrements): distVal = self.cutoffs[testIter] ldVal = self.ld[testIter] diffVal = ldVal - distVal rowResult = [distVal, ldVal, diffVal] if self.permutations: ldMinVal = self.ldMin[testIter] ldMaxVal = self.ldMax[testIter] rowResult += [ldMinVal, ldMaxVal] insert.insertRow(rowResult) #### Clean Up #### del insert #### Make Table Visable in TOC if *.dbf Had To Be Added #### if dbf: ARCPY.SetParameterAsText(1, outputTable) #### Display Results #### if displayIt: if "WIN" in SYS.platform.upper(): #### Set Progressor #### ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84186)) #### Get Image Directory #### imageDir = UTILS.getImageDir() #### Make List of Fields and Set Template File #### yFields = [expectedKName, observedKName] if self.permutations: #### Add Confidence Envelopes #### yFields.append(highKName) yFields.append(lowKName) tee = OS.path.join(imageDir, "KFunctionPlotEnv.tee") else: tee = OS.path.join(imageDir, "KFunctionPlot.tee") xFields = [ expectedKName for i in yFields ] #### Create Data Series String #### dataStr = UTILS.createSeriesStr(xFields, yFields, outputTable) #### Make Graph #### DM.MakeGraph(tee, dataStr, "KFunction") ARCPY.SetParameterAsText(11, "KFunction") else: ARCPY.AddIDMessage("Warning", 942)
def unflatten(intermediate_table): flat_zoneid = zone_field unflat_zoneid = zone_field.replace('flat', '') zone_type = [f.type for f in arcpy.ListFields(zone_fc, flat_zoneid)][0] # Set up the output table (can't do this until the prior tool is run) # if os.path.dirname(out_table): # out_path = os.path.dirname(out_table) # else: # out_path = orig_env unflat_result = DM.CreateTable('in_memory', os.path.basename(out_table)) # get the fields to add to the table editable_fields = [ f for f in arcpy.ListFields(intermediate_table) if f.editable and f.name.lower() != flat_zoneid.lower() ] # populate the new table schema DM.AddField(unflat_result, unflat_zoneid, zone_type) for f in editable_fields: DM.AddField(unflat_result, f.name, f.type, field_length=f.length) # map original zone ids to new zone ids original_flat = defaultdict(list) with arcpy.da.SearchCursor(unflat_table, [unflat_zoneid, flat_zoneid]) as cursor: for row in cursor: if row[1] not in original_flat[row[0]]: original_flat[row[0]].append(row[1]) # Use CELL_COUNT as weight for means to calculate final values for each zone. fixed_fields = [ unflat_zoneid, 'ORIGINAL_COUNT', 'CELL_COUNT', 'datacoveragepct' ] other_field_names = [ f.name for f in editable_fields if f.name not in fixed_fields ] i_cursor = arcpy.da.InsertCursor( unflat_result, fixed_fields + other_field_names) # open output table cursor flat_stats = { r[0]: r[1:] for r in arcpy.da.SearchCursor(intermediate_table, [ flat_zoneid, 'ORIGINAL_COUNT', 'CELL_COUNT', 'datacoveragepct' ] + other_field_names) } count_diff = 0 for zid, unflat_ids in original_flat.items(): valid_unflat_ids = [id for id in unflat_ids if id in flat_stats ] # skip flatpolys not rasterized area_vec = [flat_stats[id][0] for id in valid_unflat_ids ] # ORIGINAL_COUNT specified in 0 index earlier cell_vec = [flat_stats[id][1] for id in valid_unflat_ids] coverage_vec = [flat_stats[id][2] for id in valid_unflat_ids ] # datacoveragepct special handling stat_vectors_by_id = [ flat_stats[id][3:] for id in valid_unflat_ids ] # "the rest", list of lists # calc the new summarized values original_count = sum( filter(None, area_vec) ) # None area is functionally equivalent to 0, all Nones = 0 too cell_count = sum(filter(None, cell_vec)) if cell_count > 0: weighted_coverage = sum( [a * b for a, b in zip(area_vec, coverage_vec)]) / original_count # this calculation accounts for fractional missing values, both kinds (whole zone is no data, or zone # was missing some data and had data coverage % < 100). This is done by converting None to 0 # and by using the cell_count (count of cells with data present) # instead of the full zone original_count. You have to do both or the mean will be distorted. # hand-verification that this works as intended using test GIS data on was completed 2019-11-01 by NJS crossprods = [] for i in range(0, len(valid_unflat_ids)): crossprods.append([ cell_vec[i] * float(s or 0) for s in stat_vectors_by_id[i] ]) weighted_stat_means = [] for i in range(0, len(other_field_names)): weighted_stat_means.append( sum(zip(*crossprods)[i]) / cell_count) else: weighted_coverage = 0 weighted_stat_means = [None] * len(other_field_names) count_diff += 1 new_row = [zid, original_count, cell_count, weighted_coverage ] + weighted_stat_means i_cursor.insertRow(new_row) del i_cursor DM.Delete(intermediate_table) return [unflat_result, count_diff]
def swm2Table(swmFile, outputTable): """Places the spatial relationships contained in a given Spatial Weight Matrix File (*.swm) into a given output table. INPUTS: swmFile (str): Path to the input spatial weight matrix file outputTable (str): Path to the output database table """ #### Open Spatial Weights and Obtain Characteristics #### swm = WU.SWMReader(swmFile) masterField = swm.masterField N = swm.numObs rowStandard = swm.rowStandard #### Allow Overwrite Output #### ARCPY.env.overwriteOutput = True #### Get Output Table Name With Extension if Appropriate #### outputTable, dbf = UTILS.returnTableName(outputTable) #### Delete Table If Exists #### UTILS.passiveDelete(outputTable) #### Create Table #### outPath, outName = OS.path.split(outputTable) try: DM.CreateTable(outPath, outName) except: ARCPY.AddIDMessage("ERROR", 541) raise SystemExit() #### Create a List of Required Field Names #### fn = UTILS.getFieldNames(swm2TabFieldNames, outPath) neighFieldName, weightFieldName = fn fieldNames = [masterField, neighFieldName, weightFieldName] fieldTypes = ["LONG", "LONG", "DOUBLE"] for ind, field in enumerate(fieldNames): UTILS.addEmptyField(outputTable, field, fieldTypes[ind]) #### Create Insert Cursor #### try: insert = DA.InsertCursor(outputTable, fieldNames) except: ARCPY.AddIDMessage("ERROR", 204) raise SystemExit() #### Create Progressor #### ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84117), 0, N, 1) #### Process Spatial Weights File and Populate Output Table #### try: for r in xrange(N): info = swm.swm.readEntry() masterID, nn, nhs, weights, sumUnstandard = info if nn != 0: for ind, neigh in enumerate(nhs): row = [masterID, neigh, weights[ind]] insert.insertRow(row) ARCPY.SetProgressorPosition() except: swm.close() ARCPY.AddIDMessage("ERROR", 919) raise SystemExit() #### Clean Up #### del insert swm.close() #### Report if Any Features Have No Neighbors #### swm.reportNoNeighbors() #### Make Table Visable in TOC if *.dbf Had To Be Added #### if dbf: ARCPY.SetParameterAsText(1, outputTable)