def calculateOtherFields(layer): # calculate other fields arcpy.CalculateField_management( layer, "CLASSIFICA", "checkType(!CLASSIFICA!, !CLASSIFI_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "RESOURCE_T", "checkType(!RESOURCE_T!, !RESOURCE_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "ID_CLASS", "checkType(!ID_CLASS!, !ID_CLASS_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "MAIN_CLASS", "checkType(!MAIN_CLASS!, !MAIN_CLA_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "OTHER_CLAS", "checkType(!OTHER_CLAS!, !OTHER_CL_2!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "OTHER_CL_1", "checkType(!OTHER_CL_1!, !OTHER_CL_3!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "CLASS_DESC", "checkType(!CLASS_DESC!, !CLASS_DE_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "ID_TYPE", "checkType(!ID_TYPE!, !ID_TYPE_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "OTHER_TYPE", "checkType(!OTHER_TYPE!, !OTHER_TY_2!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "OTHER_TY_1", "checkType(!OTHER_TY_1!, !OTHER_TY_3!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "TYPE_DESCR", "checkType(!TYPE_DESCR!, !TYPE_DES_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "DATA_SOURC", "checkType(!DATA_SOURC!, !DATA_SOU_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "DATASET_AC", "checkType(!DATASET_AC!, !DATASET__1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "FARMING_SY", "checkType(!FARMING_SY!, !FARMING__1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "CROP_PLANT", "checkType(!CROP_PLANT!, !CROP_PLA_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "JAN", "checkType(!JAN!, !JAN_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "FEB", "checkType(!FEB!, !FEB_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "MAR", "checkType(!MAR!, !MAR_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "APR", "checkType(!APR!, !APR_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "MAY", "checkType(!MAY!, !MAY_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "JUN", "checkType(!JUN!, !JUN_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "JUL", "checkType(!JUL!, !JUL_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "AUG", "checkType(!AUG!, !AUG_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "SEP", "checkType(!SEP!, !SEP_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "OCT", "checkType(!OCT!, !OCT_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "NOV", "checkType(!NOV!, !NOV_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "DEC", "checkType(!DEC!, !DEC_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "REGION", "checkType(!REGION!, !REGION_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "PROVINCE", "checkType(!PROVINCE!, !PROVINCE_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "CITYMUNI", "checkType(!CITYMUNI!, !CITYMUNI_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "BARANGAY", "checkType(!BARANGAY!, !BARANGAY_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management( layer, "REMARKS", "checkType(!REMARKS!, !REMARKS_1!, !MAIN_TYPE!, !MAIN_TYP_1!, !UTYPE!)", "PYTHON_9.3", codeblock_type) arcpy.CalculateField_management(layer, "MAIN_TYPE", "!UTYPE!", "PYTHON_9.3") arcpy.DeleteField_management(layer, [ "CLASSIFI_1", "RESOURCE_1", "ID_CLASS_1", "MAIN_CLA_1", "OTHER_CL_2", "OTHER_CL_3", "CLASS_DE_1", "ID_TYPE_1", "MAIN_TYP_1", "OTHER_TY_2", "OTHER_TY_3", "TYPE_DES_1", "DATA_SOU_1", "DATASET__1", "FARMING__1", "CROP_PLA_1", "JAN_1", "FEB_1", "MAR_1", "APR_1", "MAY_1", "JUN_1", "JUL_1", "AUG_1", "SEP_1", "OCT_1", "NOV_1", "DEC_1", "REGION_1", "PROVINCE_1", "CITYMUNI_1", "BARANGAY_1", "REMARKS_1", "AREA_1", "SHAPE_Leng", "SHAPE_Area", "SHAPE_Le_1", "SHAPE_Ar_1" ])
arcpy.Merge_management("Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl;Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final", Merge_WDPA_flat_land, "objectid \"objectid\" true true false 9 Long 0 9 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,objectid,-1,-1;id_object \"id_object\" true true false 9 Long 0 9 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,id_object,-1,-1;id_country \"id_country\" true true false 9 Long 0 9 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,id_country,-1,-1;name_iso31 \"name_iso31\" true true false 254 Text 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,name_iso31,-1,-1;iso3 \"iso3\" true true false 254 Text 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,iso3,-1,-1;orig_fid \"orig_fid\" true true false 9 Long 0 9 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,orig_fid,-1,-1,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,ORIG_FID,-1,-1;AREA_GEO \"AREA_GEO\" true true false 3407925 Double 57 3670065 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,AREA_GEO,-1,-1,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,AREA_GEO,-1,-1;nodeID \"nodeID\" true true false 0 Long 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,nodeID,-1,-1,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,nodeID,-1,-1;ISO3final \"ISO3final\" true true false 50 Text 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/gaul_singleparted_shape_simpl,ISO3final,-1,-1,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,ISO3final,-1,-1;Shape_Length \"Shape_Length\" false true true 8 Double 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,Shape_Length,-1,-1;Shape_Area \"Shape_Area\" false true true 8 Double 0 0 ,First,#,Z:/globes/USERS/GIACOMO/protconn/data/ProtConn_Mar2020.gdb/wdpa_flat_1km2_final,Shape_Area,-1,-1") print("Gaul and wdpa_flat merged") # Process: Make Feature Layer arcpy.MakeFeatureLayer_management(Merge_WDPA_flat_land, Merge_WDPA_flat_land_lyr, "\"nodeID\" >100000", "", "OBJECTID_1 OBJECTID_1 VISIBLE NONE;Shape Shape VISIBLE NONE;objectid objectid VISIBLE NONE;id_object id_object VISIBLE NONE;id_country id_country VISIBLE NONE;name_iso31 name_iso31 VISIBLE NONE;sovereign_ sovereign_ VISIBLE NONE;sovereig_1 sovereig_1 VISIBLE NONE;sovereig_2 sovereig_2 VISIBLE NONE;iso3 iso3 VISIBLE NONE;iso2 iso2 VISIBLE NONE;un_m49 un_m49 VISIBLE NONE;source source VISIBLE NONE;status status VISIBLE NONE;original_d original_d VISIBLE NONE;original_n original_n VISIBLE NONE;source_cod source_cod VISIBLE NONE;sqkm sqkm VISIBLE NONE;orig_fid orig_fid VISIBLE NONE;AREA_GEO AREA_GEO VISIBLE NONE;cte0 cte0 VISIBLE NONE;nodeID nodeID VISIBLE NONE;ISO3final ISO3final VISIBLE NONE;Shape_Length Shape_Length VISIBLE NONE;Shape_Area Shape_Area VISIBLE NONE") # Process: Calculate Field AREA_GEO=0 arcpy.CalculateField_management(Merge_WDPA_flat_land_lyr, "AREA_GEO", "0", "PYTHON_9.3", "") print("Area_geo set to 0 for features coming from gaul (nodeid>100000)") # Process: Repair Geometry (2) arcpy.RepairGeometry_management(Merge_WDPA_flat_land, "DELETE_NULL") print("Geometries repaired, once again...") # Process: Delete Field arcpy.DeleteField_management(Merge_WDPA_flat_land, "id_object;id_country;name_iso31;sovereign_;sovereig_1;sovereig_2;iso3;iso2;un_m49;source;status;original_d;original_n;source_cod;sqkm;orig_fid;cte0") print("Useless fields deleted") # Process: Make Feature Layer 2 arcpy.MakeFeatureLayer_management(Merge_WDPA_flat_land, Merge_WDPA_flat_land_lyr2,"\"ISO3final\" LIKE '%|%'", field_info="OBJECTID_1 OBJECTID_1 VISIBLE NONE;Shape Shape VISIBLE NONE;objectid objectid VISIBLE NONE;AREA_GEO AREA_GEO VISIBLE NONE;nodeID nodeID VISIBLE NONE;ISO3final ISO3final VISIBLE NONE;Shape_Length Shape_Length VISIBLE NONE;Shape_Area Shape_Area VISIBLE NONE") # Process: Calculate Field ISO3final (assign 'DSP' to disputed territories) arcpy.CalculateField_management(Merge_WDPA_flat_land_lyr2, "ISO3final", "'DSP'", "PYTHON_9.3", "") print("Iso3 = DSP for multi-iso3 (disputed) objects") # Process: Copy Features arcpy.CopyFeatures_management(Merge_WDPA_flat_land, WDPA_plus_LAND_flat_1km2_final, "", "0", "0", "0") print("Features copied to final layer") # Process: Calculate Field objectid arcpy.CalculateField_management(WDPA_plus_LAND_flat_1km2_final, field="objectid", expression="!OBJECTID_1!", expression_type="PYTHON_9.3", code_block="")
arcpy.CalculateField_management(inputLyr, "temp", expression, "PYTHON3", codeblock) # Apply Symbology from layer for each demolition Plan month ## Get month list from the layerFileDir being defined monthList = [re.sub('.lyrx', '', _) for _ in os.listdir(layerFileDir)] #monthList= ["202101Mid", "202101End", "202102Mid", "202102End", "202103Mid", "202103End"] for m in monthList: symbolLyrx = os.path.join(layerFileDir, m + ".lyrx") arcpy.ApplySymbologyFromLayer_management( inputLyr, symbolLyrx, [["VALUE_FIELD", demolitionM, demolitionM]], update_symbology="MAINTAIN")[0] # Get the corresponding map series page numbers pages_list = Pages.split(";") # Construction boundary names pages_str = ",".join("'" + p + "'" for p in pages_list) sql = 'Station IN ({})'.format(pages_str) arcpy.SelectLayerByAttribute_management(mapSeriesLyr, "NEW_SELECTION", sql) # Get the corresponding map series page numbers msPDF = os.path.join(outputDir, asofDate + "_" + "TimeSlice_" + m + ".pdf") #ms.exportToPDF(msPDF, 'SELECTED') ms.exportToPDF(msPDF, 'SELECTED', multiple_files="PDF_MULTIPLE_FILES_PAGE_NAME") arcpy.DeleteField_management(inputLyr, "temp")
def roadNetworkEnrich(objects): networkPreProcessing(objects) network = "C:/Users/Simon/Documents/GitHub/Enrichment/networkPr_update.shp" #Deleting all the fields that are generated in this definition to prevent errors. arcpy.DeleteField_management(network, ["lightQual", "roadType", "roadQual", "roadHindr", "surfQual"]) #For the quality of street lighting. arcpy.AddField_management(network, "lightQual", "FLOAT", 4, 4, "", "", "NULLABLE") #The block of python code that allows a text variable to be reclassed into a float variable! expression1 = "Reclass(!verlichtin!, !lightQual!)" codeblock1 = """def Reclass(x, y): if (x == 'ONBEKEND' or x == 'niet verlicht'): y = 0.00 elif (x == 'beperkt verlicht (bijvoorbeeld alleen bij kruispunten)'): y = 0.50 elif (x == ' ' or x == 'goed verlicht'): y = 1.00 return y""" arcpy.CalculateField_management(network, "lightQual", expression1, "PYTHON_9.3", codeblock1) #For the type of road surface. arcpy.AddField_management(network, "roadType", "FLOAT", 4, 4, "", "", "NULLABLE") #The block of python code that allows a text variable to be reclassed into a float variable! expression1 = "Reclass(!wegdeksrt!, !roadType!)" codeblock1 = """def Reclass(x, y): if (x == ' ' or x == 'asfalt/beton'): y = 0.00 elif (x == 'klinkers' or x == 'ONBEKEND' or x == 'tegels'): y = 0.33 elif (x == 'halfverhard' or x == 'overig(hout/kinderkopjes e.d.)'): y = 0.67 elif (x == 'onverhard' or x == 'schelpenpad'): y = 1.00 return y""" arcpy.CalculateField_management(network, "roadType", expression1, "PYTHON_9.3", codeblock1) #For the quality of the surface. arcpy.AddField_management(network, "roadQual", "FLOAT", 4, 4, "", "", "NULLABLE") expression2 = "Reclass(!wegkwal!, !roadQual!)" codeblock2 = """def Reclass(x, y): if (x == 'ONBEKEND'): y = 0.50 elif (x == 'slecht'): y = 0.00 elif (x == 'redelijk'): y = 0.75 elif (x == ' ' or x == 'goed'): y = 1.00 return y""" arcpy.CalculateField_management(network, "roadQual", expression2, "PYTHON_9.3", codeblock2) #For the amount of hindrances on the surface. arcpy.AddField_management(network, "roadHindr", "FLOAT", 4, 4, "", "", "NULLABLE") expression3 = "Reclass(!hinder!, !roadHindr!)" codeblock3 = """def Reclass(x, y): if (x == ' ' or x == 'ONBEKEND'): y = 0.50 elif (x == 'zeer veel'): y = 0.00 elif (x == 'veel'): y = 0.25 elif (x == 'redelijk'): y = 0.50 elif (x == 'weinig'): y = 0.75 elif (x == 'zeer weinig'): y = 1.00 return y""" arcpy.CalculateField_management(network, "roadHindr", expression3, "PYTHON_9.3", codeblock3) #Calculating the total surface quality score. arcpy.AddField_management(network, "surfQual", "FLOAT", 4, 4, "", "", "NULLABLE") expression4 = "([roadType] + [roadQual] + [roadHindr]) / 3.0000" arcpy.CalculateField_management(network, "surfQual", expression4)
arcpy.Near_analysis(projects, feature, "", "NO_LOCATION", "NO_ANGLE") ## Add the new field if not (fieldName in projectFieldNames): arcpy.AddField_management(projects, fieldName, "DOUBLE") if (fieldName == "d_tra" or fieldName == "d_sub"): arcpy.CalculateField_management( projects, fieldName, "!NEAR_DIST! * " + str(transmissionDistMultiplier), "PYTHON_9.3") else: arcpy.CalculateField_management(projects, fieldName, "!NEAR_DIST!", "PYTHON_9.3") arcpy.DeleteField_management(projects, "NEAR_DIST") arcpy.AddMessage("Distance calculations are complete for " + fieldName) arcpy.SetProgressorPosition() arcpy.ResetProgressor() ''' ####################################### ## GET ATTRIBUTES FROM PROJECTS FILE ## ####################################### ''' ## SPATIAL JOIN ZONES' ZONEID FIELD TO PROJECTS FILE # create the fieldmap and fieldmapings object fmJoin = arcpy.FieldMap() fms = arcpy.FieldMappings() # add all the fields in the projects file to the input and output field list in the fieldmappings object fms.addTable(projects)
def RotateFeatureClass(inputFC, outputFC, angle=0, pivot_point=None): """Rotate Feature Class inputFC Input features outputFC Output feature class angle Angle to rotate, in degrees pivot_point X,Y coordinates (as space-separated string) Default is lower-left of inputFC As the output feature class no longer has a "real" xy locations, after rotation, it no coordinate system defined. """ def RotateXY(x, y, xc=0, yc=0, angle=0, units="DEGREES"): """Rotate an xy cooordinate about a specified origin x,y xy coordinates xc,yc center of rotation angle angle units "DEGREES" (default) or "RADIANS" """ x = x - xc y = y - yc # make angle clockwise (like Rotate_management) angle = angle * -1 if units == "DEGREES": angle = math.radians(angle) xr = (x * math.cos(angle)) - (y * math.sin(angle)) + xc yr = (x * math.sin(angle)) + (y * math.cos(angle)) + yc return xr, yr # temp names for cleanup env_file = None lyrFC, lyrTmp, lyrOut = [None] * 3 # layers tmpFC = None # temp dataset Row, Rows, oRow, oRows = [None] * 4 # cursors try: # process parameters try: xcen, ycen = [float(xy) for xy in pivot_point.split()] pivot_point = xcen, ycen except: # if pivot point was not specified, get it from # the lower-left corner of the feature class ext = arcpy.Describe(inputFC).extent xcen, ycen = ext.XMin, ext.YMin pivot_point = xcen, ycen angle = float(angle) # set up environment env_file = arcpy.CreateScratchName("xxenv", ".xml", "file", os.environ["TEMP"]) arcpy.SaveSettings(env_file) # Disable any GP environment clips or project on the fly arcpy.ClearEnvironment("extent") arcpy.ClearEnvironment("outputCoordinateSystem") WKS = env.workspace if not WKS: if os.path.dirname(outputFC): WKS = os.path.dirname(outputFC) else: WKS = os.path.dirname(arcpy.Describe(inputFC).catalogPath) env.workspace = env.scratchWorkspace = WKS # Disable GP environment clips or project on the fly arcpy.ClearEnvironment("extent") arcpy.ClearEnvironment("outputCoordinateSystem") # get feature class properties lyrFC = 'lyrFC' #g_ESRI_variable_1 arcpy.MakeFeatureLayer_management(inputFC, lyrFC) dFC = arcpy.Describe(lyrFC) shpField = dFC.shapeFieldName shpType = dFC.shapeType FID = dFC.OIDFieldName # create temp feature class tmpFC = arcpy.CreateScratchName("xxfc", "", "featureclass") arcpy.CreateFeatureclass_management(os.path.dirname(tmpFC), os.path.basename(tmpFC), shpType) lyrTmp = 'lyrTmp' #g_ESRI_variable_2 arcpy.MakeFeatureLayer_management(tmpFC, lyrTmp) # set up id field (used to join later) TFID = "XXXX_FID" arcpy.AddField_management(lyrTmp, TFID, "LONG") arcpy.DeleteField_management(lyrTmp, 'ID') # g_ESRI_variable_3 = 'ID' # rotate the feature class coordinates # only points, polylines, and polygons are supported # open read and write cursors Rows = arcpy.SearchCursor(lyrFC, "", "", "%s;%s" % (shpField, FID)) oRows = arcpy.InsertCursor(lyrTmp) arcpy.AddMessage("Opened search cursor") if shpType == "Point": for Row in Rows: shp = Row.getValue(shpField) pnt = shp.getPart() pnt.X, pnt.Y = RotateXY(pnt.X, pnt.Y, xcen, ycen, angle) oRow = oRows.newRow() oRow.setValue(shpField, pnt) oRow.setValue(TFID, Row.getValue(FID)) oRows.insertRow(oRow) elif shpType in ["Polyline", "Polygon"]: parts = arcpy.Array() rings = arcpy.Array() ring = arcpy.Array() for Row in Rows: shp = Row.getValue(shpField) p = 0 for part in shp: for pnt in part: if pnt: x, y = RotateXY(pnt.X, pnt.Y, xcen, ycen, angle) ring.add(arcpy.Point(x, y, pnt.ID)) else: # if we have a ring, save it if len(ring) > 0: rings.add(ring) ring.removeAll() # we have our last ring, add it rings.add(ring) ring.removeAll() # if only one, remove nesting if len(rings) == 1: rings = rings.getObject(0) parts.add(rings) rings.removeAll() p += 1 # if only one, remove nesting if len(parts) == 1: parts = parts.getObject(0) if dFC.shapeType == "Polyline": shp = arcpy.Polyline(parts) else: shp = arcpy.Polygon(parts) parts.removeAll() oRow = oRows.newRow() oRow.setValue(shpField, shp) oRow.setValue(TFID, Row.getValue(FID)) oRows.insertRow(oRow) else: raise Exception("Shape type {0} is not supported".format(shpType)) del oRow, oRows # close write cursor (ensure buffer written) oRow, oRows = None, None # restore variables for cleanup # join attributes, and copy to output arcpy.AddJoin_management(lyrTmp, TFID, lyrFC, FID) env.qualifiedFieldNames = False arcpy.Merge_management(lyrTmp, outputFC) lyrOut = 'lyrOut' #g_ESRI_variable_4 arcpy.MakeFeatureLayer_management(outputFC, lyrOut) # drop temp fields 2,3 (TFID, FID) fnames = [f.name for f in arcpy.ListFields(lyrOut)] dropList = ';'.join(fnames[2:4]) #g_ESRI_variable_5 = ';' arcpy.DeleteField_management(lyrOut, dropList) except MsgError as xmsg: arcpy.AddError(str(xmsg)) except arcpy.ExecuteError: tbinfo = traceback.format_tb(sys.exc_info()[2])[0] arcpy.AddError(tbinfo.strip()) arcpy.AddError(arcpy.GetMessages()) numMsg = arcpy.GetMessageCount() for i in range(0, numMsg): arcpy.AddReturnMessage(i) except Exception as xmsg: tbinfo = traceback.format_tb(sys.exc_info()[2])[0] arcpy.AddError(tbinfo + str(xmsg)) finally: # reset environment if env_file: arcpy.LoadSettings(env_file) # Clean up temp files for f in [lyrFC, lyrTmp, lyrOut, tmpFC, env_file]: try: if f: arcpy.Delete_management(f) except: pass # delete cursors try: for c in [Row, Rows, oRow, oRows]: del c except: pass # return pivot point try: pivot_point = "{0} {1}".format(*pivot_point) except: pivot_point = None return pivot_point
print "Step 2 completed at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") ## --------------------------------------------------------------------------- ## 3. Edit and join attribute table ## Description: Rename and delete fields print "\nStep 3 Edit attribute table starts at", datetime.datetime.now( ).strftime("%A, %B %d %Y %I:%M:%S%p") fieldsDel = [ "FID_1", "Shape__Are", "Shape__Len", "FY2016YTD", "FY2017YTD", "FY162FY17_" ] # Delete fields for fc in gdbList: arcpy.DeleteField_management(fc, fieldsDel) print "Step 3 completed at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") ## --------------------------------------------------------------------------- ## 4. Join table with feature ## Description: Join table of statistics of apprehension with the US Border Patrol Sectors feature print "\nStep 4 Join starts at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") # Convert excel table to dbf in_excel = "StatisticsApprehension.xlsx" dbf_file = os.path.splitext(in_excel)[0] joinTable = os.path.join(interFolder, dbf_file)
row[2] = cp cursor.updateRow(row) # Get a unique name listLayer = [] with arcpy.da.SearchCursor(Polylines, addField) as cursor: for row in cursor: if row[0] is not None: listLayer.append(str(row[0])) uniqueList = list(Counter(listLayer)) # Drop Field fieldNames=[f.name for f in arcpy.ListFields(Polylines)] dropField = [e for e in fieldNames if e not in (addField, addField2, 'SymbolID', 'Shape','Shape_Length','Shape_Area','Shape.STArea()','Shape.STLength()','OBJECTID','GlobalID', 'OID')] arcpy.DeleteField_management(Polylines, dropField) for types in uniqueList: # 3.1. Filter each type and copy to the file geodatabase if cp == 'N-01' and types == 'columnation': sqlExpression = "SymbolID = 0" + " AND " + "type = '{}'".format(types) elif cp == 'N-01' and types == 'station_platform': # symbolID = 9 and 10 sqlExpression = "SymbolID = 0" + " AND " + "type = '{}'".format(types) elif cp == 'N-01' and types == 'main_alignment': # symbolID = 9 and 10 sqlExpression = "SymbolID IN (0, 11)" + " AND " + "type = '{}'".format(types) elif cp == 'N-01' and types == 'mcrp_row': # symbolID = 9 and 10 sqlExpression = "SymbolID IN (9, 10)" + " AND " + "type = '{}'".format(types) elif cp == 'N-01' and types == 'centerline': sqlExpression = "SymbolID = 15" + " AND " + "type = '{}'".format(types) elif cp == 'N-03' and types == 'columnation':
def deleteFields(shapePath, fields): return arcpy.DeleteField_management(shapePath, fields)
def unplanarize(cafp, caf, connectFIDs): addMsgAndPrint('Unplanarizing ' + os.path.basename(cafp)) # add NewLineID to cafp arcpy.AddField_management(cafp, 'NewLineID', 'LONG') # go through connectFIDs to set NewLineID values addMsgAndPrint(' building newLineIDs dictionary') newLineIDs = {} for pair in connectFIDs: f1 = pair[0] f2 = pair[1] if newLineIDs.has_key(f1): if newLineIDs.has_key( f2): # both keys in dict, set all values of f2 = f1 for i in newLineIDs.keys(): if newLineIDs[i] == f2: newLineIDs[i] = newLineIDs[f1] else: # only f1 is in newLineIDs.keys() newLineIDs[f2] = newLineIDs[f1] elif newLineIDs.has_key(f2): # only f2 in newLineIDs.keys() newLineIDs[f1] = newLineIDs[f2] else: # neither f1 nor f2 in newLineIDs.keys() newLineIDs[f1] = f1 newLineIDs[f2] = f1 addMsgAndPrint(' ' + str(len(newLineIDs)) + ' entries in newLineIDs') # update cursor on cafp, if newLineIDs.has_key(caf.OFID): NewLineID = newLineIDs(caf.OFID) else NewLineID = caf.OFID addMsgAndPrint(' setting NewLineID values') with arcpy.da.UpdateCursor(cafp, ['OBJECTID', 'NewLineID']) as cursor: for row in cursor: if newLineIDs.has_key(row[0]): row[1] = newLineIDs[row[0]] else: row[1] = row[0] cursor.updateRow(row) # dissolve cafp on GeMS attribs and NewLineID to get cafu cafu = cafp.replace('planarized', 'unplanarized') addMsgAndPrint(' dissolving to get ' + os.path.basename(cafu)) testAndDelete(cafu) dissolveFields = gemsFields if 'Notes' in fieldNameList(cafp): dissolveFields.append('Notes') dissolveFields.append('NewLineID') arcpy.Dissolve_management(cafp, cafu, dissolveFields, '', '', 'UNSPLIT_LINES') # delete NewLineID from caf_unplanarized. maybe add _ID field?? arcpy.DeleteField_management(cafu, 'NewLineID') addMsgAndPrint( str(numberOfRows(caf)) + ' arcs in ' + os.path.basename(caf)) addMsgAndPrint( str(numberOfRows(cafp)) + ' arcs in ' + os.path.basename(cafp)) addMsgAndPrint( str(numberOfRows(cafu)) + ' arcs in ' + os.path.basename(cafu)) txtPath = os.path.join(outWksp, 'connectedFIDs.txt') outTxt = open(txtPath, 'w') connectFIDs.sort() for aline in connectFIDs: outTxt.write( str(aline) + ' ' + str(newLineIDs[aline[0]]) + ' ' + str(newLineIDs[aline[1]]) + '\n') outTxt.close() return cafu
def wetlands_in_zones(zones_fc, zone_field, wetlands_fc, output_table, dissolve_wetlands=True): # make sure we're only using the right types of wetlands, our feature # class excludes everything else but this is a guarantee this will # get checked at some point arcpy.env.workspace = 'in_memory' need_selection = False with arcpy.da.SearchCursor(wetlands_fc, ["ATTRIBUTE", "WETLAND_TYPE"]) as cursor: while need_selection is False: for row in cursor: if row[0][0] <> 'P': need_selection = True if row[1] <> 'Freshwater Pond': need_selection = True if need_selection: main_expr = """"ATTRIBUTE" LIKE 'P%'AND "WETLAND_TYPE" <> 'Freshwater_Pond'""" arcpy.Select_analysis(wetlands_fc, "wetlands_fc_checked", main_expr) wetlands_fc = os.path.join(arcpy.env.workspace, "wetlands_fc_checked") selections = [ '', """"WetOrder" = 'Isolated'""", """"WetOrder" = 'Single'""", """"WetOrder" = 'Connected'""", """"VegType" = 'PFO'""", """"VegType" = 'PSS'""", """"VegType" = 'PEMorPAB'""", """"Regime" = 'A'""", """"Regime" = 'C'""", """"Regime" = 'F'""", """"Regime" = 'G'""", """"Regime" = 'H'""" ] temp_tables = [ 'AllWetlandsUndissolved', 'IsolatedWetlandsUndissolved', 'SingleWetlandsUndissolved', 'ConnectedWetlandsUndissolved', 'ForestedWetlandsUndissolved', 'ScrubShrubWetlandsUndissolved', 'OpenWaterWetlandsUndissolved', 'RegimeAWetlandsUndissolved', 'RegimeCWetlandsUndissolved', 'RegimeFWetlandsUndissolved', 'RegimeGWetlandsUndissolved', 'RegimeHWetlandsUndissolved' ] for sel, temp_table in zip(selections, temp_tables): if sel: print( "Creating temporary table for wetlands where {0}".format(sel)) selected_wetlands = 'selected_wetlands' arcpy.Select_analysis(wetlands_fc, selected_wetlands, sel) else: print("Creating temporary table for all wetlands") selected_wetlands = wetlands_fc if dissolve_wetlands == True: arcpy.Dissolve_management(selected_wetlands, 'dissolved_wetlands', multi_part='SINGLE_PART') dissolved_temp_table = temp_table.replace( 'Undissolved', 'Dissolved') temp_tables.append(dissolved_temp_table) polygons_in_zones.polygons_in_zones(zones_fc, zone_field, 'dissolved_wetlands', dissolved_temp_table, '') new_fields = [ 'Poly_Overlapping_AREA_ha', 'Poly_Contributing_AREA_ha', 'Poly_Overlapping_AREA_pct', 'Poly_Count' ] avg_size_field = dissolved_temp_table + '_AvgSize_ha' arcpy.AddField_management(dissolved_temp_table, avg_size_field, 'DOUBLE') arcpy.CalculateField_management( dissolved_temp_table, avg_size_field, '!Poly_Contributing_AREA_ha!/!Poly_Count!', 'PYTHON') for f in new_fields: cu.rename_field(dissolved_temp_table, f, f.replace('Poly', dissolved_temp_table), True) polygons_in_zones.polygons_in_zones(zones_fc, zone_field, selected_wetlands, temp_table, '') new_fields = [ 'Poly_Overlapping_AREA_ha', 'Poly_Contributing_AREA_ha', 'Poly_Overlapping_AREA_pct', 'Poly_Count' ] avg_size_field = temp_table + '_AvgSize_ha' arcpy.AddField_management(temp_table, avg_size_field, 'DOUBLE') arcpy.CalculateField_management( temp_table, avg_size_field, '!Poly_Contributing_AREA_ha!/!Poly_Count!', 'PYTHON') for f in new_fields: cu.rename_field(temp_table, f, f.replace('Poly', temp_table), True) # join em up and copy to final temp_tables.remove('AllWetlandsUndissolved') for t in temp_tables: try: arcpy.JoinField_management('AllWetlandsUndissolved', zone_field, t, zone_field) # sometimes there's no table if it was an empty selection except: empty_fields = [f.replace('Poly', t) for f in new_fields] for ef in empty_fields: arcpy.AddField_management('AllWetlandsUndissolved', ef, 'Double') arcpy.CalculateField_management('AllWetlandsUndissolved', ef, '0', 'PYTHON') continue # remove all the extra zoneID fields, which have underscore in name drop_fields = [ f.name for f in arcpy.ListFields('AllWetlandsUndissolved', zone_field + "_*") ] for f in drop_fields: arcpy.DeleteField_management('AllWetlandsUndissolved', f) arcpy.CopyRows_management('AllWetlandsUndissolved', output_table) for item in [ 'AllWetlandsUndissolved', 'wetlands_fc_checked', 'dissolved_wetlands' ] + temp_tables: try: arcpy.Delete_management(item) except: continue arcpy.ResetEnvironments()
def planarizeAndGetArcEndPoints(fds, caf, mup, fdsToken): # returns a feature class of endpoints of all caf lines, two per planarized line segment addMsgAndPrint('Planarizing ' + os.path.basename(caf) + ' and getting segment endpoints') # add LineID (so we can recover lines after planarization) arcpy.AddField_management(caf, 'LineID', 'LONG') arcpy.CalculateField_management(caf, 'LineID', '!OBJECTID!', 'PYTHON_9.3') # planarize CAF by FeatureToLine addMsgAndPrint(' planarizing caf') planCaf = caf + '_xxx_plan' testAndDelete(planCaf) arcpy.FeatureToLine_management(caf, planCaf) # planarize CAF (by IDENTITY with MUP) addMsgAndPrint(' IDENTITYing caf with mup') cafp = caf + '_planarized' testAndDelete(cafp) arcpy.Identity_analysis(planCaf, mup, cafp, 'ALL', '', 'KEEP_RELATIONSHIPS') # delete extra fields addMsgAndPrint(' deleting extra fields') fns = fieldNameList(cafp) deleteFields = [] for f in fieldNameList(mup): if f <> 'MapUnit': for hf in ('RIGHT_' + f, 'LEFT_' + f): if hf in fns: deleteFields.append(hf) arcpy.DeleteField_management(cafp, deleteFields) # calculate azimuths startDir and endDir addMsgAndPrint(' adding StartAzimuth and EndAzimuth') for f in ('LineDir', 'StartAzimuth', 'EndAzimuth'): arcpy.AddField_management(cafp, f, 'FLOAT') arcpy.AddField_management(cafp, 'ToFrom', 'TEXT', '', '', 4) fields = ['SHAPE@', 'StartAzimuth', 'EndAzimuth'] with arcpy.da.UpdateCursor(cafp, fields) as cursor: for row in cursor: lineSeg = row[0].getPart(0) row[1], row[2] = startEndGeogDirections(lineSeg) cursor.updateRow(row) # make endpoint feature class addMsgAndPrint(' converting line ends to points') arcEndPoints = fds + '/' + fdsToken + 'xxx_EndPoints' # will be a feature class in fds arcEndPoints2 = arcEndPoints + '_end' testAndDelete(arcEndPoints) arcpy.FeatureVerticesToPoints_management(cafp, arcEndPoints, 'START') arcpy.CalculateField_management(arcEndPoints, 'LineDir', '!StartAzimuth!', 'PYTHON') arcpy.CalculateField_management(arcEndPoints, 'ToFrom', '"From"', 'PYTHON') testAndDelete(arcEndPoints2) arcpy.FeatureVerticesToPoints_management(cafp, arcEndPoints2, 'END') arcpy.CalculateField_management(arcEndPoints2, 'LineDir', '!EndAzimuth!', 'PYTHON') arcpy.CalculateField_management(arcEndPoints2, 'ToFrom', '"To"', 'PYTHON') arcpy.Append_management(arcEndPoints2, arcEndPoints) testAndDelete(arcEndPoints2) # delete some more fields deleteFields = [ 'EndAzimuth', 'StartAzimuth', 'LEFT_MapUnitPolys', 'RIGHT_MapUnitPolys' ] arcpy.DeleteField_management(arcEndPoints, deleteFields) addMsgAndPrint(' adding POINT_X and POINT_Y') arcpy.AddXY_management(arcEndPoints) testAndDelete(planCaf) return cafp, arcEndPoints
if row[0] == "In Production" or row[0] == "Not Started" or row[ 0] == "On Hold" or row[0] == "Ready For Submission": row[1] = "In Design" elif row[0] == "Permitted": row[1] = "Permits Received" elif row[0] == "Entity Review" or row[0] == "Respond To Entity Review": row[1] = "Permits Submitted" elif row[0] == "Comm Moves In Progress": row[1] = "Comm Moves In Progress" cursor.updateRow(row) arcpy.DeleteField_management(dissolvePath, 'MIN_STATUS_CODE') ##### Clementini Selection of Trans_PermitPoly_SpJoin & Export to GDB (PG. 9) ##### arcpy.MakeFeatureLayer_management(outSpatJoin, "spatJoinLyr") arcpy.SelectLayerByLocation_management("spatJoinLyr", "CONTAINS_CLEMENTINI", dissolvePath, "", "NEW_SELECTION") result4 = arcpy.GetCount_management("spatJoinLyr") print "... " + str(result4) + " records selected" print("\n") arcpy.SelectLayerByAttribute_management("spatJoinLyr", "SWITCH_SELECTION") result5 = arcpy.GetCount_management("spatJoinLyr") print "... " + str(result5) + " records were reverse selected" print("\n")
# import and merge git/manual_output/sp_rgn_manual.csv for editing #arcpy.Dissolve_management('sp_m', 'sp_m_d', ['sp_type','sp_id','sp_name','sp_key']) # redo sp_id ... d = pandas.DataFrame(arcpy.da.TableToNumPyArray('sp_m_d', ['OBJECTID','sp_type','sp_id','sp_name','sp_key'])) # print(set(d['sp_type'])) # set([u'ccamlr', u'land', u'eez', u'land-noeez', u'fao', u'eez-inland']) # convert from Unicode to ASCII for matching lookup for u,a in {u'Curaçao':'Curacao', u'République du Congo':'Republique du Congo', u'Réunion':'Reunion'}.iteritems(): # u=u'Réunion'; a='Reunion' d.ix[d.sp_name==u,'sp_name'] = a d = d.rename(columns={'sp_type':'sp_type_orig','sp_name':'sp_name_orig', 'sp_id':'sp_id_orig','sp_key':'sp_key_orig'}) z = pandas.io.parsers.read_csv(sp_rgn_csv) # , encoding='utf-8') #z_cols = ['sp_type','sp_name_orig','sp_id','sp_name','sp_key','rgn_typ','rgn_id','rgn_name','rgn_key','country_id_2012','region_id_2012','region_name_2012'] m = pandas.merge(d, z, how='left', on=['sp_type_orig','sp_name_orig']) # missing and duplicate checks should return 0 rows: # m[m.sp_name.isnull()][['sp_type_orig','sp_name_orig']] # m[m.duplicated('OBJECTID')].sort(['sp_type_orig','sp_name_orig'])[['sp_type_orig','sp_name_orig']] arcpy.AddField_management('sp_m_d', 'OID', 'LONG') arcpy.CalculateField_management('sp_m_d', 'OID', '!OBJECTID!', 'PYTHON_9.3') arcpy.CopyFeatures_management('sp_m_d','sp_m_d_i') arcpy.DeleteField_management('sp_m_d_i', [x.name for x in arcpy.ListFields('sp_m_d_i') if x.name not in ('OBJECTID','OID','Shape','Shape_Length','Shape_Area')]) r = m[['OBJECTID', 'sp_type','sp_id','sp_name','sp_key', 'rgn_type','rgn_id','rgn_name','rgn_key', 'cntry_id12','rgn_id12','rgn_name12']].to_records(index=False) # m[[x for x in m.columns if x!='Shape_Area']] r = r.astype( [('OBJECTID', '<i4'), ('sp_type' , '<U20'), ('sp_id' , '<i4'), ('sp_name' , '<U255'), ('sp_key' , '<U10'), ('rgn_type' , '<U20'), ('rgn_id' , '<i4'), ('rgn_name' , '<U255'), ('rgn_key' , '<U10'), ('cntry_id12' ,'<U255'), ('rgn_id12' , '<i4'), ('rgn_name12' , '<U255'), ('notes' , '<U255')]) arcpy.da.ExtendTable('sp_m_d_i', 'OID', r, 'OBJECTID', append_only=False) arcpy.Dissolve_management('sp_m_d_i', 'sp_gcs' , ['sp_type','sp_id','sp_name','sp_key','rgn_type','rgn_id','rgn_name','rgn_key','cntry_id12','rgn_id12','rgn_name12']) arcpy.Dissolve_management('sp_m_d_i', 'rgn_gcs', ['rgn_type','rgn_id','rgn_name','rgn_key']) arcpy.RepairGeometry_management('sp_gcs') arcpy.RepairGeometry_management('rgn_gcs')
print("Extracting elevation") ExtractValuesToPoints(outProfPt, inDEM, "temp_elev") print(" Attaching elevation to profile points") arcpy.JoinField_management(outProfPt, "OBJECTID", "temp_elev", "OBJECTID", "RASTERVALU") print(" Renaming field") arcpy.AlterField_management(outProfPt, "RASTERVALU", "Elevation", "#", "#", "#", "#", "True") # Attaching geology age print("Attaching geology info") # delete fields if exist for fld in [geolField, ageMinField, ageMaxField]: if fld in [f.name for f in arcpy.ListFields(outProfPt)]: print(" Deleting " + fld + " field") arcpy.DeleteField_management(outProfPt, fld) print(" Performing Identity") arcpy.Identity_analysis(outProfPt, inGeol, "temp_" + fld) print(" Joining geology info to summary points") arcpy.JoinField_management(outProfPt, "OBJECTID", "temp_" + fld, "FID_" + outProfPt, [geolField, ageMinField, ageMaxField]) # Writing profile files print("Writing files") with arcpy.da.SearchCursor(inProfile, [profIDField]) as line_cursor: for line_row in line_cursor: profID = line_row[0] # get profile id print(" Profile: " + str(profID)) outFile = os.path.join(outCSVFolder, "profile_" + str(profID) + ".csv") # set output file
arcpy.AddMessage(" ") arcpy.AddMessage("Calculate length of GPS tracks.") arcpy.AddMessage(" ") expression0 = "!shape.length@miles!" arcpy.CalculateField_management(fc1, fieldName0, expression0, "PYTHON") arcpy.AddMessage("Buffer GPS tracks to account for sweepwidth and team size.") arcpy.AddMessage(" ") # Buffer areas around GPS track bufferUnit = "meters" distanceField = "TeamSweep_m" sideType = "GPSLoc" dissolveType = "NONE" arcpy.Buffer_analysis(fc1, fc5, Sweep, "", "", dissolveType, "") arcpy.DeleteField_management(fc1, "Sweep") del bufferUnit del distanceField del sideType del dissolveType del Sweep # Execute AddField arcpy.AddField_management(fc5, fieldName8, "SHORT") arcpy.CalculateField_management(fc5, fieldName8, "1", "PYTHON") arcpy.AddMessage( "Intersection analysis between GPS tracks and Search Segments") arcpy.AddMessage(" ") # Process: Intersect
r = arcpy.CopyRows_management("Parcels2", PD_Notify, "") print(r[0]) # Process: Add Field r = arcpy.AddField_management(PD_Notify, "address", "TEXT", "", "", "50", "", "NULLABLE", "NON_REQUIRED", "") print(r[0]) # Process: Calculate Field r = arcpy.CalculateField_management( PD_Notify, "address", "!House_Num! + ' ' + !Street_Name! + ' ' + !Street_Type!", "PYTHON_9.3", "") print(r[0]) # Process: Delete Field r = arcpy.DeleteField_management( PD_Notify, "SubName;BLK;LotNo;Pre_Type;Pre_Dir;House_Num;Street_Name;Street_Type;Suffix_Dir;Use_Code;PlatStatus" ) print(r[0]) arcpy.CopyRows_management(r, "D:/GISProjects/accident/temp.txt") filein = open("D:/GISProjects/accident/temp.txt", 'r') for row in csv.reader(filein): outstr = row[-1] print(outstr) filein.close() os.remove("D:/GISProjects/accident/temp.txt")
#=============================================================================== # CODING #=============================================================================== #/creation of the final stream network # The sequencing module will operate on this layer arcpy.AddMessage("Creating final shp - Step 0") InputFCMTS_TEMP = arcpy.MultipartToSinglepart_management(InputFC, "%ScratchWorkspace%\\InputFCMTS_TEMP") InputFCMTS = arcpy.Intersect_analysis([InputFCMTS_TEMP, InputFCMTS_TEMP], "%ScratchWorkspace%\\InputFCMTS", "", "", "") fieldnamesInFC = [f.name for f in arcpy.ListFields(InputFCMTS_TEMP)] fieldnamesOutFC = [f.name for f in arcpy.ListFields(InputFCMTS)] for fieldOut in fieldnamesOutFC : if str(fieldOut) not in str(fieldnamesInFC) : arcpy.DeleteField_management(InputFCMTS, str(fieldOut)) arcpy.AddField_management(InputFCMTS, "Rank_UGO", "SHORT", "", "", "", "","NULLABLE", "NON_REQUIRED") arcpy.AddField_management(InputFCMTS, "NextDownID", "SHORT", "", "", "", "","NULLABLE", "NON_REQUIRED") arcpy.AddField_management(InputFCMTS, "NextUpID", "SHORT", "", "", "", "","NULLABLE", "NON_REQUIRED") arcpy.AddField_management(InputFCMTS, "From_X", "DOUBLE", "", "", "", "","NULLABLE", "NON_REQUIRED") #/creation of the up and down points if path[size-4:size] == ".gdb" : UDPts = arcpy.FeatureVerticesToPoints_management(InputFCMTS, OutFP, "BOTH_ENDS") else : UDPts = arcpy.FeatureVerticesToPoints_management(InputFCMTS, "%ScratchWorkspace%\\UDPts", "BOTH_ENDS") fieldnamesUDPts = [f.name for f in arcpy.ListFields(UDPts)] for field in fieldnamesUDPts : try :
"", "", "") expression = "getClass(!VALUE!)" codeblock = """def getClass(a): if a == 1: return u"极重要" if a == 3: return u"高度重要" else: return u'一般重要'""" arcpy.CalculateField_management(OUTPUTPATH + OUTPUTNAME + ".tif", "fbl", FBLL, "PYTHON_9.3") arcpy.CalculateField_management(OUTPUTPATH + OUTPUTNAME + ".tif", "dengji", expression, "PYTHON_9.3", codeblock) arcpy.CalculateField_management(OUTPUTPATH + OUTPUTNAME + ".tif", "mj", "(!fbl!)*(!COUNT!)", "PYTHON_9.3") arcpy.DeleteField_management(OUTPUTPATH + OUTPUTNAME + ".tif", "fbl") arcpy.Delete_management("stfwshp.shp") arcpy.Delete_management("stmgshp.shp") arcpy.Delete_management("stjcshp.shp") arcpy.Delete_management("jc.tif") if arcpy.Exists("tihuan1.tif"): arcpy.Delete_management("tihuan1.tif") if arcpy.Exists("tihuan.tif"): arcpy.Delete_management("tihuan.tif") ###################################### RasterTableToTxtAndExcel.write2excel(OUTPUTPATH + OUTPUTNAME + ".tif", OUTPUTPATH, OUTPUTNAME) if IN_XZQQ != "99999": StaticticsByXZQ.StatisticBYXZQ(OUTPUTPATH + OUTPUTNAME + ".tif", IN_XZQQ, OUTPUTPATH, OUTPUTNAME + "_XZQ") arcpy.AddColormap_management(OUTPUTPATH + OUTPUTNAME + ".tif", "#",
fieldmappings.replaceFieldMap(bikefieldindex, fieldmap) pedfieldindex = fieldmappings.findFieldMapIndex("MeanPedRating") fieldmap2 = fieldmappings.getFieldMap(pedfieldindex) fieldmap2.mergeRule = "mean" fieldmappings.replaceFieldMap(pedfieldindex, fieldmap2) arcpy.SpatialJoin_analysis("ZonesJoin13", "RoadsWithPathways", "DemandScore", "JOIN_ONE_TO_ONE", "KEEP_ALL", fieldmappings, "INTERSECT") print("Spatial Joins Complete!") removefields = getFieldNames("DemandScore") print(removefields) arcpy.DeleteField_management("DemandScore", removefields) # Clean up - delete intermediate feature classes print("Deleting intermediate feature classes...") removefcs = [ "ZonesJoin1", "ZonesJoin2", "ZonesJoin3", "ZonesJoin4", "ZonesJoin5", "ZonesJoin6", "ZonesJoin7", "ZonesJoin8", "ZonesJoin9", "ZonesJoin10", "ZonesJoin11", "ZonesJoin12", "ZonesJoin13" ] for f in removefcs: arcpy.Delete_management(f) print("Intermediate feature classes deleted!") # Deal with null values in scores fields
"", "", "", "NULLABLE", "NON_REQUIRED", "") except arcpy.ExecuteError, error: print "" # pfnRemarks arcpy.AddField_management(output, "pfnRemarks", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") try: arcpy.CalculateField_management( output, "pfnRemarks", remarks, "VB", "") except arcpy.ExecuteError, error: print "" #Process : Delete Field print "Removing Fields : " + fields arcpy.DeleteField_management(output, fields) #2 elif jens == "2": print "Pulau" # objID arcpy.AddField_management(output, "objID", "SHORT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") # objType arcpy.AddField_management(output, "objType", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(output, "objType", types, "VB", "") # objYear
row.setValue(fieldCapMNo, "-99") value15 = row.getValue(fieldSurHa) if value15 < 0: row.setValue(fieldSurHa, "-99") value16 = row.getValue(fieldDrainSqk) if value16 < 0: row.setValue(fieldDrainSqk, "-99") cur.updateRow(row) print "Step 6 completed at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") ## --------------------------------------------------------------------------- ## 7. Export the feature class ## Description: Rename fields, Add new fields (units in U.S. system) print "\nStep 7 Export starts at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") for fc in clipList: name = os.path.split(fc)[1] out_feature = os.path.join(finalFolder, name + ".shp") arcpy.CopyFeatures_management(fc, out_feature) arcpy.DeleteField_management(out_feature, "OID_") print "Step 7 completed at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p") print "Geoprocess Dams completed at", datetime.datetime.now().strftime( "%A, %B %d %Y %I:%M:%S%p")
## --------------------------------------------------------------------------- ## 3. Homogeneize fields ## Description: Add and delete fields print "\nStep 3 Add and delete fields starts at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p") fieldName = "STATE_AGEN" fieldNameList = [fieldName] fieldAlias = 'STATE_AGENCY' fieldType = "TEXT" fieldsDel = ["AREA", "PERIMETER"] # Add field for x in fieldNameList: arcpy.AddField_management(out_featureclass, x, fieldType, "", "", 75, fieldAlias) arcpy.DeleteField_management(out_featureclass, fieldsDel) #Update lines cur = arcpy.UpdateCursor(out_featureclass) for row in cur: row.setValue(fieldName, 'TCEQ') cur.updateRow(row) print "Step 3 completed at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p") ## --------------------------------------------------------------------------- ## 4. Project the polygon and calculate new area ## Description: Project to North America Albers Equal Area Conic print "\nStep 4 Project starts at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p")
for n in rec_list: d = [] fields0 = [c.name for c in arcpy.ListFields(n) if not c.required] arcpy.AddMessage(fields0) for k in fields0: if k == "VALUE" or k == "COUNT": d.append(k) arcpy.AddMessage("k=" + k) else: arcpy.AddMessage("k value yada count deðil") pass if len(fields0) > 2 and len(d) == 2: fields0.remove(d[0]) fields0.remove(d[1]) arcpy.DeleteField_management(n, fields0) arcpy.AddMessage(n + "Fields_Silindi.......") ##-Analiz Hesaplamalari Yapýlýyor------------------------- hey_list = arcpy.ListDatasets("hey_rec*", "Raster") for j, k in zip(rec_list, hey_list): arcpy.JoinField_management(j, "Value", k, "Value", "count") lst = [] lst2 = [] lstmax = [] lstmin = [] top_pix_field = "count", "hp" fieldTpx = ['sumtpx', 'sumlpx'] max_min = "max", "min" for l in rec_list: outname = str("tablo" + (l) + ".dbf")
def delete_dir2_fields(temp_arc): ''' Delete all <FIELDNAME>2 fields, leaving only the A-to-B directional values. ''' arcpy.DeleteField_management(temp_arc, ['{0}2'.format(field) for field in dir_fields]) arcpy.DeleteField_management(temp_arc, ['DIRECTIONS']) return temp_arc
def WVT(city, inDir, workFld): import traceback, time, arcpy, os from arcpy import env arcpy.CheckOutExtension('Spatial') #-------- DIRECTORY SETUP ------------------------------------------------ """ Working Directory """ try: arcpy.CreateFileGDB_management(str(workFld), str(city) + '_TreeWV.gdb') except: print 'TreeWV GDB already exists' workDir = str(workFld) + '/' + city + '_TreeWV.gdb' arcpy.env.workspace = workDir """ Report File Directory """ reportfileDir = str(workFld) + '/Logs' """ Frequent Directory """ freqDir = str(workFld) + '/' + city + '_Freq.gdb' """ Final Geodatabase """ finalDir = str(workFld) + '/' + city + '_Final.gdb' """ Projection File Directory """ prjDir = str(inDir) + '/Prj' prjfile = prjDir + '/USA Contiguous Albers Equal Area Conic USGS.prj' """ Split Raster Directory """ if os.path.isdir(str(workFld) + '/' + city + '_Split') == True: pass else: os.makedirs(str(workFld) + '/' + city + '_Split') splitDir = str(workFld) + '/' + city + '_Split' """ Set Workspace Environments """ arcpy.env.workspace = workDir arcpy.env.scratch = str(inDir) + '/Scratch.gdb' arcpy.env.overwriteOutput = True #----------------------------------------------------------------------------- # BEGIN ANALYSIS #----------------------------------------------------------------------------- try: #-------- LOGFILE CREATION --------------------------------------------- """ Create report file for each metric """ tmpName = city + '_TreeWV_' + time.strftime('%Y%m%d_%H-%M') reportfileName = reportfileDir + '/' + tmpName + '.txt' reportFile = open(reportfileName, 'w') try: loglist = sorted(f for f in os.listdir(reportfileDir) if f.startswith(str(city) + '_Reuse')) tmpName = loglist[-1] except: tmpName = city + '_Reuse_' + time.strftime('%Y%m%d_%H-%M') + '.txt' reportfileName = reportfileDir + '/' + tmpName try: ReuseRF = open(reportfileName, 'a') except: ReuseRF = open(reportfileName, 'w') print 'Creating Reuse Log' """ Write out first line of report file """ print 'Window Views of Trees Start Time: ' + time.asctime() reportFile.write( "Begin with EnviroAtlas 1-meter Land Cover for the EnviroAtlas community--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') #-------- PROCESSING LAYERS ---------------------------------------------- """ Set Environments """ arcpy.env.snapRaster = freqDir + '/LC' arcpy.env.extent = freqDir + '/LC' arcpy.env.overwriteOutput = True """-------- Reclassify LC into Binary Forest ----------------------------- """ if arcpy.Exists(str(freqDir) + '/MForestIO') == False: outReclass = arcpy.sa.Reclassify( str(freqDir) + '/LC', 'Value', arcpy.sa.RemapValue([[0, 0], [10, 0], [20, 0], [21, 0], [22, 0], [30, 0], [40, 1], [52, 0], [70, 0], [80, 0], [82, 1], [91, 1], [92, 0]])) outReclass.save(str(freqDir) + '/MForestIO') reportFile.write( "Reclassify the Land Cover into a Forest binary REPLACE-MFE" + time.strftime('%Y%m%d--%H%M%S') + '--\n') print("Forest area reclassified to binary raster..." + time.asctime()) ReuseRF.write("MForestIO--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') else: print("Forest binary raster already exists..." + time.asctime()) reportFile.write( "Reclassify the Land Cover into a Forest binary REPLACE-MFE--MForestIO" + '--\n') """-------- Create 50m Moving Window ------------------------------------- """ MW = arcpy.sa.FocalStatistics(freqDir + '/MForestIO', arcpy.sa.NbrCircle(50, 'CELL'), 'SUM', 'NODATA') MW.save('MFor_50C') print("Moving window complete..." + time.asctime()) reportFile.write( "Run Focal Statistics on the Forest Binary Raster with a circular window of 50 meters and statistics = SUM.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- Reclassify Moving Window into Trees/NoTrees ------------------- """ ReC = arcpy.sa.Reclassify( 'MFor_50C', 'Value', arcpy.sa.RemapRange([[0, 0.99999, 1], [0.99999, 10300, 0]])) ReC.save('NoForView') print( "Moving window completed and reclassified to tree / no trees..." + time.asctime()) reportFile.write( "Reclassify the Focal Statistics into Forest (>0 -> 0) or No Forest (0 -> 1).--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- Split the Raster As Needs, Process Each Piece ----------------- """ """ Check if the raster should be split """ columns = arcpy.GetRasterProperties_management( 'NoForView', 'COLUMNCOUNT').getOutput(0) xsplit = int(float(columns) / 20000) + 1 rows = arcpy.GetRasterProperties_management('NoForView', 'ROWCOUNT').getOutput(0) ysplit = int(float(rows) / 20000) + 1 """-------- If no split, run the analysis --------------------------------- """ if xsplit * ysplit == 1: """ Convert Raster to Polygon """ arcpy.RasterToPolygon_conversion('NoForView', 'NFVP_Whole', 'NO_SIMPLIFY') """ Extract areas with no forest in 50m """ arcpy.Select_analysis('NFVP_Whole', 'NFVS_Whole', 'gridcode=1') reportFile.write( "Convert the raster into a polygon and select the features where gridcode = 1.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Project into Albers for use with Dasymetric """ arcpy.Project_management('NFVS_Whole', 'NFVA_Whole', prjfile) print("Raster small enough, carry on..." + time.asctime()) reportFile.write("Convert the polygons into Albers projection.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- If split, run the analysis on each piece and recombine --------- """ else: """ Delete the raster, if necessary """ xy = (xsplit * ysplit) for rast in range(xy): try: arcpy.Delete_management(splitDir + '/nfvsp_' + str(rast)) except: pass try: arcpy.Delete_management(splitDir + '/noforview') except: pass """ Split the Raster """ arcpy.RasterToOtherFormat_conversion('NoForView', splitDir, 'GRID') print("Raster too big, splitting into " + str(xsplit) + " rows and " + str(ysplit) + " columns..." + time.asctime()) arcpy.SplitRaster_management(splitDir + '/NoForView', splitDir, 'NFVSp_', 'NUMBER_OF_TILES', 'GRID', '', str(xsplit) + ' ' + str(ysplit)) reportFile.write( "Split the raster into pieces for easier processing. The Python script determines the number of pieces based on the number of rows and columns in the raster where no piece can have a side larger than 20,000 cells--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ For each raster: """ prjfile = prjDir + '/USA Contiguous Albers Equal Area Conic USGS.prj' xy = (xsplit * ysplit) for Chunk in range(0, xy): try: result = float( arcpy.GetRasterProperties_management( splitDir + '/NFVSp_' + str(Chunk), 'MEAN').getOutput(0)) """ If the raster piece has data: """ if (result > 0): """ Set Environments """ arcpy.env.snapRaster = freqDir + '/MForestIO' arcpy.env.extent = freqDir + '/MForestIO' """ Copy the piece back to the Working Directory """ arcpy.RasterToOtherFormat_conversion( splitDir + '/NFVSp_' + str(Chunk), workDir) """ Convert Raster to Polygon """ arcpy.RasterToPolygon_conversion( 'NFVSp_' + str(Chunk), 'NFVP_' + str(Chunk), 'NO_SIMPLIFY') """ Extract areas with no forest in 50m """ arcpy.Select_analysis('NFVP_' + str(Chunk), 'NFVS_' + str(Chunk), 'gridcode=1') """ Project into Albers for use with Dasymetric """ arcpy.Project_management('NFVS_' + str(Chunk), 'NFVA_' + str(Chunk), prjfile) print("Chunk " + str(Chunk) + " / " + str(xy) + " processed..." + time.asctime()) except: pass reportFile.write( "For each piece, convert the raster into a polygon and select the features where gridcode = 1--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') reportFile.write( "For each piece, convert the polygons into Albers projection.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Combine the resulting polygons """ NFVchunks = arcpy.ListFeatureClasses('NFVA_*') arcpy.Merge_management(NFVchunks, workDir + '/NFVA_Whole') print("All chunks remerged..." + time.asctime()) reportFile.write( "Merge all of the projected polygons together.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Set Environments """ arcpy.env.snapRaster = freqDir + '/Dasy' arcpy.env.extent = freqDir + '/Dasy' """-------- End of Split Processing ---------------------------------------- """ """ Extract Dasymetric Pixels where there is no forest in 50m """ EbM = arcpy.sa.ExtractByMask(freqDir + '/Dasy', 'NFVA_Whole') EbM.save('Pop_NoForView') reportFile.write( "Extract by Mask the EnviroAtlas Dasymetric (2011/October 2015) pixels within the polygons--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Calculate the Extracted Dasy Population with Each CBG """ arcpy.sa.ZonalStatisticsAsTable(freqDir + '/BG_Alb', 'bgrp', 'Pop_NoForView', 'BG_TWV', 'DATA', 'SUM') reportFile.write( "Calculate Zonal Statistics as Table for the extracted dasymetrics with the zones being the 2010 block groups for the EnviroAtlas community.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- Calculate Total Dasy Population, if necessary ------------------ """ """ Use the existing data """ fieldNames = [f.name for f in arcpy.ListFields(freqDir + '/BG_Alb')] if 'Dasy_Pop' in fieldNames: reportFile.write( "Calculate Zonal Statistics as a Table for the EnviroAtlas Dasymetrics (2011/October 2015) with the zones being the 2010 block groups within the EnviroAtlas community boundary. Add resulting population sums to the community block groups as attribute Dasy_Pop--Dasy_Pop" + '--\n') """ Create population data """ else: arcpy.AddField_management(freqDir + '/BG_Alb', 'Dasy_Pop', 'LONG') ZonalStatisticsAsTable(freqDir + '/BG_Alb', 'bgrp', freqDir + '/Dasy', freqDir + '/Dasy_ZS', '', 'SUM') arcpy.JoinField_management(freqDir + '/BG_Alb', 'bgrp', freqDir + '/Dasy_ZS', 'bgrp', ['SUM']) arcpy.CalculateField_management(freqDir + '/BG_Alb', 'Dasy_Pop', '!SUM!', 'PYTHON_9.3') arcpy.DeleteField_management(freqDir + '/BG_Alb', ['SUM']) arcpy.JoinField_management(freqDir + '/BG', 'bgrp', freqDir + '/BG_Alb', 'bgrp', ['Dasy_Pop']) reportFile.write( "Calculate Zonal Statistics as a Table for the EnviroAtlas Dasymetrics (2011/October 2015) with the zones being the 2010 block groups within the EnviroAtlas community boundary. Add resulting population sums to the community block groups as attribute Dasy_Pop--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') ReuseRF.write("Dasy_Pop--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- Create Final Table --------------------------------------------- """ arcpy.TableToTable_conversion(freqDir + '/BG_Alb', workDir, 'TreeWV', '', 'bgrp') arcpy.DeleteField_management('TreeWV', [ 'PLx2_Pop', 'PLx2_Pct', 'SUM_HOUSIN', 'NonWhite', 'LandA_M', 'Density', 'under_1', 'under_1pct', 'under_13', 'under_13pc', 'over_70', 'over_70pct', 'Shape_Length', 'Shape_Leng', 'NonWhite_Pop', 'NonWt_Pct', 'Area_M', 'Shape_Le_1', 'Shape_Area', 'ALAND', 'NonWhite_P', 'H_Income_M', 'State' ]) TreeView = 'TreeWV' reportFile.write( "Create a new table based on the EnviroAtlas community block groups table retaining the BGRP and Dasy_Pop fields--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Add fields to new table """ arcpy.AddField_management(TreeView, 'WVT_Pop', 'LONG') arcpy.AddField_management(TreeView, 'WVT_Pct', 'FLOAT', 5, 2) reportFile.write( "Add fields to the new table for WVT_Pop (long), WVT_Pct (float).--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Join Each Table to the final table and WVW_Pop """ arcpy.JoinField_management(TreeView, 'bgrp', 'BG_TWV', 'bgrp', ['SUM']) arcpy.CalculateField_management(TreeView, 'WVT_Pop', '!SUM!', 'PYTHON_9.3') arcpy.MakeTableView_management(TreeView, 'TreeView_Tbl') arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'NEW_SELECTION', 'SUM IS NULL') arcpy.CalculateField_management('TreeView_Tbl', 'WVT_Pop', 0, 'PYTHON_9.3') arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'CLEAR_SELECTION') arcpy.DeleteField_management('TreeView_Tbl', 'SUM') reportFile.write( "Join the zonal statistics table with the new table to calculate the new fields: WVT_Pop = zonal statistics.SUM; remove join--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Calculate WVT_Pct """ arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'NEW_SELECTION', 'Dasy_Pop >0') arcpy.CalculateField_management( 'TreeView_Tbl', 'WVT_Pct', '"%.2f" % (float(!WVT_Pop!)/float(!Dasy_Pop!) * 100)', 'PYTHON_9.3') arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'CLEAR_SELECTION') reportFile.write( "Calculate field WVT_Pct = WVT_Pop / Dasy_Pop * 100 (limited to 2 decimal places).--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Calculate NULL values, where applicable """ arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'NEW_SELECTION', 'Dasy_Pop = 0') arcpy.CalculateField_management('TreeView_Tbl', 'WVT_Pct', '-99999', 'PYTHON_9.3') arcpy.CalculateField_management('TreeView_Tbl', 'WVT_Pop', '-99999', 'PYTHON_9.3') arcpy.SelectLayerByAttribute_management('TreeView_Tbl', 'CLEAR_SELECTION') arcpy.DeleteField_management('TreeView_Tbl', [ 'SUM_POP10', 'EAID', 'NonWhite', 'LandA_M', 'Density', 'Dasy_Pop', 'SUM' ]) print("Dasy raster summarized to BGs and stats calculated..." + time.asctime()) reportFile.write( "Calculate fields where Dasy_Pop = 0: All Fields = -99999.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """-------- Check that the Analysis Area is covered by the LC -------------- """ """ Create a Polygon Version of the LC """ if arcpy.Exists(freqDir + '/LC_Poly') == False: arcpy.env.extent = freqDir + '/LC' arcpy.env.snapRaster = freqDir + '/LC' ReC = arcpy.sa.Reclassify( str(freqDir) + '/LC', 'Value', arcpy.sa.RemapValue([[0, 0], [10, 1], [20, 1], [21, 1], [22, 1], [30, 1], [40, 1], [52, 1], [70, 1], [80, 1], [82, 1], [91, 1], [92, 1]])) ReC.save(str(freqDir) + '/AreaIO') arcpy.RasterToPolygon_conversion( str(freqDir) + '/AreaIO', str(freqDir) + '/LC_Poly', 'SIMPLIFY') arcpy.EliminatePolygonPart_management( str(freqDir) + '/LC_Poly', str(freqDir) + '/LC_Poly_EP', 'PERCENT', '', '5', 'CONTAINED_ONLY') arcpy.Delete_management(str(freqDir) + '/LC_Poly') arcpy.Rename_management( str(freqDir) + '/LC_Poly_EP', str(freqDir) + '/LC_Poly') """ Buffer the LC Polygon by -500m """ if arcpy.Exists(freqDir + '/Bnd_Cty_500m') == False: arcpy.Buffer_analysis( str(freqDir) + '/Bnd_Cty', str(freqDir) + '/Bnd_Cty_500m', '500 meters') arcpy.EliminatePolygonPart_management( str(freqDir) + '/Bnd_Cty_500m', str(freqDir) + '/Bnd_Cty_500m_EP', 'PERCENT', '', '30', 'CONTAINED_ONLY') arcpy.Delete_management(str(freqDir) + '/Bnd_Cty_500m') arcpy.Rename_management( str(freqDir) + '/Bnd_Cty_500m_EP', str(freqDir) + '/Bnd_Cty_500m') """ Identify whether LC is large enough """ arcpy.MakeFeatureLayer_management(str(freqDir) + '/LC_Poly', 'LClyr') arcpy.MakeFeatureLayer_management( str(freqDir) + '/Bnd_Cty_500m', 'BC_500lyr') arcpy.SelectLayerByLocation_management('BC_500lyr', 'COMPLETELY_WITHIN', 'LClyr', '', 'NEW_SELECTION') bigEnough = float(arcpy.GetCount_management('BC_500lyr').getOutput(0)) arcpy.SelectLayerByAttribute_management('BC_500lyr', 'CLEAR_SELECTION') """ If the LC isn't large enough, edit erroneous BGS """ if bigEnough == 0: """ Identify BGs within 50m of the LC edge """ arcpy.Buffer_analysis( str(freqDir) + '/LC_Poly', 'LC_Poly_Minus50', '-50 meters', 'FULL', 'FLAT', 'ALL') arcpy.MakeFeatureLayer_management('LC_Poly_Minus50', 'Minus50') arcpy.MakeFeatureLayer_management(freqDir + '/BG', 'BG') arcpy.SelectLayerByLocation_management('BG', 'COMPLETELY_WITHIN', 'Minus50', '', 'NEW_SELECTION', 'INVERT') bgValue = float(arcpy.GetCount_management('BG').getOutput(0)) print("LC extends beyond BG boundary, carry on..." + time.asctime()) """ For all BGs too close to the LC edge, assign both fields a value of -99998 """ if bgValue > 0: bgrps = [] cursor = arcpy.SearchCursor('BG') for row in cursor: value = row.getValue('bgrp') bgrps.append(value) bgrps = list(set(bgrps)) expression = '' for bgrp in bgrps: expression = expression + " OR bgrp = '" + str(bgrp) + "'" expression = expression[4:] arcpy.SelectLayerByAttribute_management( 'TreeView_Tbl', 'NEW_SELECTION', expression) arcpy.CalculateField_management('TreeView_Tbl', 'WVT_Pop', '-99998', 'PYTHON_9.3') arcpy.CalculateField_management('TreeView_Tbl', 'WVT_Pct', '-99998', 'PYTHON_9.3') arcpy.SelectLayerByAttribute_management( 'TreeView_Tbl', 'CLEAR_SELECTION') print( "LC doesn't extend beyond BGs, removing border BGs from analysis..." + time.asctime()) reportFile.write( "Calculate Field for BGs within 50m of the edge of the land cover, WVT_Pop and WVW_Pct = -99998.--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') """ Create final table """ arcpy.CopyRows_management('TreeView_Tbl', 'TreeWV_Fnl') try: arcpy.Delete_management(finalDir + '/' + str(city) + '_TreeWV') except: pass arcpy.TableToTable_conversion('TreeWV_Fnl', finalDir, city + '_TreeWV') allFields = [ f.name for f in arcpy.ListFields(finalDir + '/' + city + '_TreeWV') ] for field in allFields: if field not in ['bgrp', 'OBJECTID', 'WVT_Pop', 'WVT_Pct']: arcpy.DeleteField_management(finalDir + '/' + city + '_TreeWV', [field]) print 'Window Views of Trees End Time: ' + time.asctime() + '\n' reportFile.write( "Export the fields to be displayed in the EnviroAtlas to a final gdb table. WVT_Pop, WVT_Pct--" + time.strftime('%Y%m%d--%H%M%S') + '--\n') #-------- COMPELETE LOGFILES --------------------------------------------- reportFile.close() ReuseRF.close() #----------------------------------------------------------------------------- # END ANALYSIS #----------------------------------------------------------------------------- except: """ This part of the script executes if anything went wrong in the main script above """ #-------- PRINT ERRORS --------------------------------------------------- print "\nSomething went wrong.\n\n" print "Python Traceback Message below:" print traceback.format_exc() print "\nArcMap Error Messages below:" print arcpy.GetMessages(2) print "\nArcMap Warning Messages below:" print arcpy.GetMessages(1) #-------- COMPLETE LOGFILE ------------------------------------------------ reportFile.write("\nSomething went wrong.\n\n") reportFile.write("Pyton Traceback Message below:") reportFile.write(traceback.format_exc()) reportFile.write("\nArcMap Error Messages below:") reportFile.write(arcpy.GetMessages(2)) reportFile.write("\nArcMap Warning Messages below:") reportFile.write(arcpy.GetMessages(1)) reportFile.write("\n\nEnded at " + time.asctime() + '\n') reportFile.write("\n---End of Log File---\n") if reportFile: reportFile.close()
arcpy.env.workspace = str(os.path.join(tools_folder, gdb, pmn)) arcpy.env.overwriteOutput = True print arcpy.env.workspace # Process: Project (moving) print 'Moving Feature ' + output + ' to Database' #project arcpy.Project_management( shp, output, "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", "", "", "NO_PRESERVE_SHAPE", "", "NO_VERTICAL") #Process : Delete Field print 'Deleting Originals Fields for Feature ' + output # pmnID try: arcpy.DeleteField_management(output, "wadName") except arcpy.ExecuteError, error: continue print "repeat" except arcpy.ExecuteError, error: print "Something went wrong handling " + ". Here's a traceback:" print output continue else: pass lompati = lompati + 1
SelectionPoints = arcpy.SelectLayerByAttribute_management( MakeFracTEMPToPoints, "NEW_SELECTION", "\"NEAR_FID\" IS NULL") SelectLine = arcpy.SelectLayerByLocation_management(MakeFracTEMP, "BOUNDARY_TOUCHES", SelectionPoints, "", "NEW_SELECTION") arcpy.CalculateField_management(SelectLine, "Fusion", "10000", "VB", "") FracPoly_TEMP = arcpy.Dissolve_management(FracTEMP, "%ScratchWorkspace%\\FracPoly_TEMP", "Fusion", "", "MULTI_PART", "DISSOLVE_LINES") FracPoly = arcpy.MultipartToSinglepart_management( FracPoly_TEMP, "%ScratchWorkspace%\\FracPoly") arcpy.DeleteField_management(FracPoly, "Fusion") ncurrentstep += 1 arcpy.AddMessage("Split the input polygon - Step " + str(ncurrentstep) + "/" + str(nstep)) PolySplitTEMP = dS.SLEM(FracPoly, DisaggregationStep, "%ScratchWorkspace%\\PolySplitTEMP", ScratchW, "true") PolySplit = arcpy.Sort_management( PolySplitTEMP, "%ScratchWorkspace%\\PolySplit", [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) ncurrentstep += 1 arcpy.AddMessage("Converting Split polygon to points - Step " + str(ncurrentstep) + "/" + str(nstep)) PolySplitToPoint = arcpy.FeatureToPoint_management( PolySplit, "%ScratchWorkspace%\\PolySplitToPoint", "INSIDE")
def execute(self, params, messages): arcpy.AddMessage( """Welcome to the Source Feature and EO Assigner! This tool is designed to prepare a feature class or shapefile for bulk load into Biotics by assigning an existing or new SFID and EOID grouping variable to observations based on eparation distance. This used to be done manually, so sit back and enjoy all the other work you can be doing instead of this!""" ) in_points = params[0].valueAsText in_lines = params[1].valueAsText in_poly = params[2].valueAsText species_code = params[3].valueAsText lu_separation = params[4].valueAsText eo_reps = params[5].valueAsText eo_id_field = params[6].valueAsText eo_sourcept = params[7].valueAsText eo_sourceln = params[8].valueAsText eo_sourcepy = params[9].valueAsText sf_id_field = params[10].valueAsText species_code_field = params[11].valueAsText arcpy.env.workspace = "in_memory" arcpy.AddMessage("Preparing input data") #prepare single fc from biotics sf fcs sfs_in = [eo_sourcept, eo_sourceln, eo_sourcepy] sfs_out = ["eo_sourcept", "eo_sourceln", "eo_sourcepy"] for sf_in, sf_out in zip(sfs_in, sfs_out): arcpy.Buffer_analysis(sf_in, sf_out, 1) sf_merge = arcpy.Merge_management(sfs_out, "sf_merge") sf_lyr = arcpy.MakeFeatureLayer_management(sf_merge, "sf_lyr") data_in = [] data_out = [] if in_points: data_in.append(in_points) data_out.append("pts") if in_lines: data_in.append(in_lines) data_out.append("lines") if in_poly: data_in.append(in_poly) data_out.append("polys") join_id = 1 for i, o in zip(data_in, data_out): arcpy.AddField_management(i, "temp_join_id", "TEXT") with arcpy.da.UpdateCursor(i, "temp_join_id") as cursor: for row in cursor: row[0] = str(join_id) cursor.updateRow(row) join_id += 1 arcpy.Buffer_analysis(i, o, 1) data_merge = arcpy.Merge_management(data_out, "data_merge") data_lyr = arcpy.MakeFeatureLayer_management(data_merge, "data_lyr") if arcpy.ListFields(data_lyr, species_code)[0].type == 'Integer': species_query = "{}={}" else: species_query = "{}='{}'" if arcpy.ListFields(data_lyr, species_code_field)[0].type == 'Integer': eo_species_query = "{}={}" else: eo_species_query = "{}='{}'" #get name of true OID field objectid_field = arcpy.Describe(data_lyr).OIDFieldName #create feature layers to allow for selections eo_reps = arcpy.MakeFeatureLayer_management(eo_reps, "eo_reps") #add EO/SF ID fields if they do not already exist add_fields_text = ["SF_ID", "SF_NEW", "EO_ID", "EO_NEW"] for field in add_fields_text: if len(arcpy.ListFields(data_lyr, field)) == 0: arcpy.AddField_management(data_lyr, field, "TEXT", "", "", 50) add_fields_int = ["UNIQUEID"] for field in add_fields_int: if len(arcpy.ListFields(data_lyr, field)) == 0: arcpy.AddField_management(data_lyr, field, "LONG") #set word index to assign words to new EO groups word_index = 1 observation_num = 1 arcpy.AddMessage("Beginning to assign EO IDs") #get total records in data_lyr for progress reporting messages total_obs = arcpy.GetCount_management(data_lyr) #start assigning loop search_fields = [ objectid_field, "EO_ID", "EO_NEW", species_code, lu_separation ] with arcpy.da.SearchCursor(data_lyr, search_fields) as cursor: for row in cursor: objectid = row[0] #if one of the EOID fields already have a value, continue on to next feature if row[2] != None and (row[1] != None or row[1] != 0): arcpy.AddMessage( "ObjectID " + str(objectid) + " EO Observation number " + str(observation_num) + "/" + str(total_obs) + " has already been assigned to a new or existing EO.") pass else: sname = row[3] distance = str(row[4] * 1000) + " METERS" #select feature and assign sname and separation distance variables arcpy.SelectLayerByAttribute_management( data_lyr, "NEW_SELECTION", "{}={}".format(objectid_field, objectid)) #check for existing EO reps within separation distance of feature arcpy.SelectLayerByAttribute_management( eo_reps, 'NEW_SELECTION', eo_species_query.format(species_code_field, sname)) arcpy.SelectLayerByLocation_management( eo_reps, "WITHIN_A_DISTANCE", data_lyr, distance, "SUBSET_SELECTION") #check for selection on eo_reps layer - if there is a selection, get eoid, select all observations within the separation distance, and assign existing eoid to selected features selection_num = arcpy.Describe(eo_reps).fidset if selection_num is not u'': with arcpy.da.SearchCursor(eo_reps, eo_id_field) as cursor: #eoid = sorted({row[0] for row in cursor}, reverse=True)[0] #use this if keeping newest EO eoid = ",".join( sorted({str(row[0]) for row in cursor}) ) #use this if filling with EOIDs of all EOs within separation distance #set arbitrary unequal counts to start while loop countBefore = 0 countAfter = 1 while (countBefore != countAfter): countBefore = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) arcpy.SelectLayerByLocation_management( data_lyr, "WITHIN_A_DISTANCE", data_lyr, distance, "ADD_TO_SELECTION") arcpy.SelectLayerByAttribute_management( data_lyr, "SUBSET_SELECTION", species_query.format(species_code, sname)) countAfter = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) with arcpy.da.UpdateCursor(data_lyr, "EO_ID") as cursor: for row in cursor: row[0] = str(eoid) cursor.updateRow(row) arcpy.AddMessage( "ObjectID " + str(objectid) + ", along with " + str(countAfter - 1) + " observations were assigned an existing EO: " + str(eoid) + ". " + str(observation_num) + "/" + str(total_obs) + " completed.") #if no existing EOs selected within separation distance, select all observations within the separation distance and assign new random word else: countBefore = 0 countAfter = 1 while (countBefore != countAfter): countBefore = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) arcpy.SelectLayerByLocation_management( data_lyr, "WITHIN_A_DISTANCE", data_lyr, distance, "ADD_TO_SELECTION") arcpy.SelectLayerByAttribute_management( data_lyr, "SUBSET_SELECTION", species_query.format(species_code, sname)) countAfter = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) with arcpy.da.UpdateCursor(data_lyr, "EO_NEW") as cursor: for row in cursor: row[0] = str( word_index) #word_list[word_index] cursor.updateRow(row) arcpy.AddMessage( "ObjectID " + str(objectid) + ", along with " + str(countAfter - 1) + " observations were assigned a new EO: " + str(word_index) + ". " + str(observation_num) + "/" + str(total_obs) + " completed.") word_index += 1 observation_num += 1 arcpy.SelectLayerByAttribute_management( data_lyr, "CLEAR_SELECTION") arcpy.AddMessage("Beginning to assign SF IDs") observation_num = 1 search_fields = [objectid_field, "SF_ID", "SF_NEW", species_code] with arcpy.da.SearchCursor(data_lyr, search_fields) as cursor: for row in cursor: objectid = row[0] if row[2] != None and (row[1] != None or row[1] != 0): arcpy.AddMessage( "ObjectID " + str(objectid) + " SF Observation number " + str(observation_num) + "/" + str(total_obs) + " has already been assigned to a new or existing SF.") else: sname = row[3] #check for existing SFs within 9m of feature (8m because of 1m buffer on SF layers) arcpy.SelectLayerByAttribute_management( data_lyr, "NEW_SELECTION", "{}={}".format(objectid_field, objectid)) arcpy.SelectLayerByAttribute_management( sf_lyr, 'NEW_SELECTION', eo_species_query.format(species_code_field, sname)) arcpy.SelectLayerByLocation_management( sf_lyr, "WITHIN_A_DISTANCE", data_lyr, "7 METERS", "SUBSET_SELECTION") #check for selection on sf_merge layer - if there is a selection, get sfid, select all observations within the separation distance, and assign existing eoid to selected features if arcpy.Describe('sf_lyr').fidset is not u'': with arcpy.da.SearchCursor('sf_lyr', sf_id_field) as cursor: #sfid = sorted({row[0] for row in cursor}, reverse=True)[0] #use this line if you want to use the newest SF ID within separation distance sfid = ",".join( sorted({str(row[0]) for row in cursor}) ) # use this line if you want to list all SF IDs within separation distance countBefore = 0 countAfter = 1 while (countBefore != countAfter): countBefore = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) arcpy.SelectLayerByLocation_management( data_lyr, "WITHIN_A_DISTANCE", data_lyr, "7 METERS", "ADD_TO_SELECTION") arcpy.SelectLayerByAttribute_management( data_lyr, "SUBSET_SELECTION", species_query.format(species_code, sname)) countAfter = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) with arcpy.da.UpdateCursor(data_lyr, "SF_ID") as cursor: for row in cursor: row[0] = sfid cursor.updateRow(row) arcpy.AddMessage( "ObjectID " + str(objectid) + ", along with " + str(countAfter - 1) + " observations were assigned an existing SF: " + str(sfid) + ". " + str(observation_num) + "/" + str(total_obs) + " completed.") #if no existing SFs selected within separation distance, select all observations within the separation distance and assign new random word else: countBefore = 0 countAfter = 1 while (countBefore != countAfter): countBefore = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) arcpy.SelectLayerByLocation_management( data_lyr, "WITHIN_A_DISTANCE", data_lyr, "7 METERS", "ADD_TO_SELECTION") arcpy.SelectLayerByAttribute_management( data_lyr, "SUBSET_SELECTION", species_query.format(species_code, sname)) countAfter = int( arcpy.GetCount_management( "data_lyr").getOutput(0)) with arcpy.da.UpdateCursor( data_lyr, ["SF_NEW", "EO_NEW"]) as cursor: for row in cursor: if row[1] != None: sf_id = row[1] + "_" + str( word_index) #word_list[word_index] row[0] = sf_id else: sf_id = str( word_index) #word_list[word_index] row[0] = sf_id cursor.updateRow(row) arcpy.AddMessage( "ObjectID " + str(objectid) + ", along with " + str(countAfter - 1) + " observations were assigned a new SF: " + sf_id + ". " + str(observation_num) + "/" + str(total_obs) + " completed.") word_index += 1 observation_num += 1 arcpy.SelectLayerByAttribute_management( data_lyr, "CLEAR_SELECTION") #create unique id value for each unique source feature i = 1 with arcpy.da.SearchCursor(data_lyr, ["SF_ID", "SF_NEW", "UNIQUEID"]) as cursor: sfid1 = sorted({row[0] for row in cursor}) with arcpy.da.SearchCursor(data_lyr, ["SF_ID", "SF_NEW", "UNIQUEID"]) as cursor: sfid2 = sorted({row[1] for row in cursor}) sfid = sfid1 + sfid2 sfid = [x for x in sfid if x is not None] sfid = [x.encode('UTF8') for x in sfid] for sf in sfid: with arcpy.da.UpdateCursor( data_lyr, ["SF_ID", "SF_NEW", "UNIQUEID"]) as cursor: for row in cursor: if row[0] == sf: row[2] = i cursor.updateRow(row) elif row[1] == sf: row[2] = i cursor.updateRow(row) else: pass i += 1 add_fields = add_fields_int + add_fields_text for data in data_in: arcpy.JoinField_management(data, "temp_join_id", data_lyr, "temp_join_id", add_fields) arcpy.DeleteField_management(data, "temp_join_id") arcpy.Delete_management("in_memory") return
def calculateJoinedFields(layer): # calculate other fields arcpy.CalculateField_management(layer, "MAIN_TYPE", "!MAIN_TYP_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "CLASSIFICA", "!CLASSIFI_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "RESOURCE_T", "!RESOURCE_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "ID_CLASS", "!ID_CLASS_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "MAIN_CLASS", "!MAIN_CLA_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "OTHER_CLAS", "!OTHER_CL_2!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "OTHER_CL_1", "!OTHER_CL_3!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "CLASS_DESC", "!CLASS_DE_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "ID_TYPE", "!ID_TYPE_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "OTHER_TYPE", "!OTHER_TY_2!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "OTHER_TY_1", "!OTHER_TY_3!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "TYPE_DESCR", "!TYPE_DES_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "DATA_SOURC", "!DATA_SOU_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "DATASET_AC", "!DATASET__1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "FARMING_SY", "!FARMING__1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "CROP_PLANT", "!CROP_PLA_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "JAN", "!JAN_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "FEB", "!FEB_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "MAR", "!MAR_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "APR", "!APR_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "MAY", "!MAY_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "JUN", "!JUN_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "JUL", "!JUL_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "AUG", "!AUG_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "SEP", "!SEP_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "OCT", "!OCT_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "NOV", "!NOV_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "DEC", "!DEC_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "REGION", "!REGION_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "PROVINCE", "!PROVINCE_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "CITYMUNI", "!CITYMUNI_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "BARANGAY", "!BARANGAY_1!", "PYTHON_9.3") arcpy.CalculateField_management(layer, "REMARKS", "!REMARKS_1!", "PYTHON_9.3") arcpy.DeleteField_management(layer, [ "UTYPE", "NEAR_FID", "NEAR_DIST", "CLASSIFI_1", "RESOURCE_1", "ID_CLASS_1", "MAIN_CLA_1", "OTHER_CL_2", "OTHER_CL_3", "CLASS_DE_1", "ID_TYPE_1", "MAIN_TYP_1", "OTHER_TY_2", "OTHER_TY_3", "TYPE_DES_1", "DATA_SOU_1", "DATASET__1", "FARMING__1", "CROP_PLA_1", "JAN_1", "FEB_1", "MAR_1", "APR_1", "MAY_1", "JUN_1", "JUL_1", "AUG_1", "SEP_1", "OCT_1", "NOV_1", "DEC_1", "REGION_1", "PROVINCE_1", "CITYMUNI_1", "BARANGAY_1", "REMARKS_1" ])