def convert_raster_2_polygon():
output_urb = r"V:"
output_hdc = r"V:"
arcpy.RasterToPolygon_conversion(urb_Clst_Grid, output_urb, "NO_SIMPLIFY",
"VALUE")
arcpy.RasterToPolygon_conversion(hdens_Clst_Grid, output_hdc,
"NO_SIMPLIFY", "VALUE")
def generate_binned_shapefiles(inputRaster, num_bins_list):
intRas = Int(Raster(inputRaster))
intPolygon = r'C:\user\Documents\workspace\heatmap-dev\anonCrimeHeatmap\int_simplified.shp'
intPolygon2 = r'C:\user\Documents\workspace\heatmap-dev\anonCrimeHeatmap\int_notsimplified.shp'
arcpy.RasterToPolygon_conversion(intRas, intPolygon, 'SIMPLIFY',
'VALUE') # do the conversion
arcpy.RasterToPolygon_conversion(intRas, intPolygon2, 'NO_SIMPLIFY',
'VALUE') # do the conversion
rasterMax = arcpy.GetRasterProperties_management(intRas, 'MAXIMUM')
rasterMax = float(rasterMax.getOutput(0))
for num_bins in num_bins_list:
remapRange = RemapRange(
get_remap_table_for_remap_range(num_bins, rasterMax))
binnedRas = Reclassify(intRas, 'VALUE', remapRange, 'NODATA')
# location of temporary polygon
tempPolygon = r'C:\user\Documents\workspace\heatmap-dev\anonCrimeHeatmap\\' + str(
num_bins) + '_bins_simplified.shp'
arcpy.RasterToPolygon_conversion(binnedRas, tempPolygon, 'SIMPLIFY',
'VALUE') # do the conversion
tempPolygon2 = r'C:\user\Documents\workspace\heatmap-dev\anonCrimeHeatmap\\' + str(
num_bins) + '_bins_notsimplified.shp'
arcpy.RasterToPolygon_conversion(binnedRas, tempPolygon2,
'NO_SIMPLIFY',
'VALUE') # do the conversion
def hru1(path, intslope):
import arcpy, os, re
#from arcpy.sa import *
from arcpy import env
arcpy.env.workspace = path
print(
'converting landuse, soil, and slope raster to polygon and delineation of HRU map'
)
# converting landuse, slope, and soil rasters to feature class and overlaying the created feature classes
arcpy.RasterToPolygon_conversion("type_sol.tif", 'soil_poly',
"NO_SIMPLIFY", "VALUE")
arcpy.RasterToPolygon_conversion("occupation_sol.tif", 'LU_poly',
"NO_SIMPLIFY", "VALUE")
arcpy.RasterToPolygon_conversion(
intslope, 'pente_poly', "NO_SIMPLIFY", "VALUE"
) # raster to polygon conversion accepts only the integer type raster
# add the new fields in created polygons and copy the value into it.
arcpy.AddField_management("soil_poly.shp", "soil_type", "SHORT", "", "",
"", "", "", "", "")
arcpy.AddField_management("LU_poly.shp", "LU_type", "SHORT", "", "", "",
"", "", "", "")
arcpy.AddField_management("pente_poly.shp", "slope", "FLOAT", "", "", 32,
"", "", "", "")
arcpy.Delete_management("times.tif")
arcpy.Delete_management("slope_in_deg.tif")
# copy the created fields to new fields
arcpy.CalculateField_management("soil_poly.shp", "soil_type", "!gridcode!",
"PYTHON_9.3")
arcpy.DeleteField_management("soil_poly.shp", "gridcode")
arcpy.CalculateField_management("LU_poly.shp", "LU_type", "!gridcode!",
"PYTHON_9.3")
arcpy.DeleteField_management("LU_poly.shp", "gridcode")
arcpy.CalculateField_management("pente_poly.shp", "slope",
"!gridcode!/100.0", "PYTHON_9.3")
arcpy.DeleteField_management("pente_poly.shp", "gridcode")
# overlain the soil type, land use, and slope for creating the HRU map
arcpy.Intersect_analysis(["soil_poly.shp", "LU_poly.shp"], "HRU1", "ALL")
arcpy.Intersect_analysis(["HRU1.shp", "pente_poly.shp"], "HRU2", "ALL")
# delete HRU1 from directory and unnecessary fields in attribute table of HRU2
arcpy.Delete_management("HRU1.shp")
arcpy.Delete_management("soil_poly.shp")
arcpy.Delete_management("pente_poly.shp")
arcpy.Delete_management("LU_poly.shp")
arcpy.DeleteField_management("HRU2.shp", [
"FID_HRU1", "FID_soil_p", "FID_LU_pol", "FID_pente_", "Id", "Id_1",
"Id_12"
])
print('done!')
def create_path_footprints(image_directory, burn_raster_path):
'''
Given a directory containing .tif images and a path to an 0 constant raster this function will add 1 to every raster
pixel where there is meaningful data in the raster. Converts to shapefile in directory and burns based on the
output polygon geometry. Puts those shapefiles into a temporary directory then removes the directory.
:param image_directory: The directory containing the raster images
:param burn_raster_path: The path to the 0 constant raster. Should be of an extent that contains all the paths.
:return:
'''
temp_dir = tempfile.mkdtemp()
for image in get_files_of_ext(image_directory, '.tif'):
image_name = os.path.splitext(os.path.basename(image))[0]
# con_raster = custom_nodata(bands_to_raster_obj(image, get_band_list(image))) for bsq images
raster = Raster(image)
mask_raster = Con((raster == 0) | (raster == 1), 1, 0)
output_path = os.path.join(temp_dir, image_name + '.shp')
arcpy.RasterToPolygon_conversion(mask_raster, output_path, "NO_SIMPLIFY")
add_to_raster(burn_raster_path, output_path)
shutil.rmtree(temp_dir)
return
def main():
# Setup script path and workspace folder
outWorkspace = flmc.SetupWorkspace("FLM_CSR_output")
arcpy.env.workspace = outWorkspace
arcpy.env.overwriteOutput = True
# Load arguments from file
args = flmc.GetArgs("FLM_CSR_params.txt")
# Tool arguments
InShapefile = args[0].rstrip()
InRaster = args[1].rstrip()
ShrinkSize = args[2].rstrip()
OutShapefile = args[3].rstrip()
# Local variables:
FLM_CSR_IsNull = outWorkspace+"\\FLM_CSR_IsNull.tif"
FLM_CSR_SetNull = outWorkspace+"\\FLM_CSR_SetNull.tif"
FLM_CSR_Shrink = outWorkspace+"\\FLM_CSR_Shrink.tif"
FLM_CSR_RasterPoly = outWorkspace+"\\FLM_CSR_RasterPoly.shp"
arcpy.gp.IsNull_sa(InRaster, FLM_CSR_IsNull)
arcpy.gp.SetNull_sa(FLM_CSR_IsNull, "1", FLM_CSR_SetNull, "Value = 1")
arcpy.gp.Shrink_sa(FLM_CSR_SetNull, FLM_CSR_Shrink, ShrinkSize, "1")
arcpy.RasterToPolygon_conversion(FLM_CSR_Shrink, FLM_CSR_RasterPoly, simplify="NO_SIMPLIFY", raster_field="Value", create_multipart_features="SINGLE_OUTER_PART", max_vertices_per_feature="")
arcpy.Clip_analysis(InShapefile, FLM_CSR_RasterPoly, OutShapefile, cluster_tolerance="0 Meters")
def split_strahler(stream_area_fc, streams, out_area_fc):
"""This function splits up the NHDArea feature class, which does not
start and stop polygons at confluences, by creating break points near the
confluences to split up the polygons. Then, it adds the Strahler value from
the stream centerline."""
# 1) Generate euclidean allocation raster from streams (use OBJECTID)
# 2) Convert euclidean allocation raster to polygons
# 3) Join allocation polygons "gridcode" to streams "OBJECTID" so that
# Strahler value is attached to allocation polygon
# 4) Use identity function to split up the StreamRiver polygons at the
# allocation polygon boundaries, and add the Strahler values
old_workspace = env.workspace
env.workspace = 'in_memory'
cu.multi_msg(
"Splitting stream area polygons between confluences and joining 1) Strahler order to them..."
)
cu.multi_msg('next messages for testing')
arcpy.CheckOutExtension('Spatial')
cu.multi_msg('euc')
euc = EucAllocation(streams, cell_size='50', source_field='OBJECTID')
arcpy.CheckInExtension('Spatial')
cu.multi_msg('conversion')
arcpy.RasterToPolygon_conversion(euc, 'allocation_polys')
stream_id_field = arcpy.ListFields(streams, 'Permanent_')[0].name
cu.multi_msg('join')
arcpy.JoinField_management('allocation_polys', 'grid_code', streams,
'OBJECTID',
['Strahler', 'LengthKm', stream_id_field])
cu.multi_msg('identity')
arcpy.Identity_analysis(stream_area_fc, 'allocation_polys', out_area_fc)
env.workspace = old_workspace
cu.multi_msg("Splitting strema area polygons finished.")
def rasterizeSinglebeam(points,
mb,
out="__rast",
number=6,
radius=18,
overWrite=False):
import arcpy
from arcpy.sa import *
if overWrite:
arcpy.env.overwriteOutput = True
outIDW = Idw(points, "bottom_elevation", 3, 2,
RadiusVariable(number, radius))
if mb:
conRast = Con(outIDW, 1, '', '')
poly = arcpy.RasterToPolygon_conversion(conRast, "_poly" + points,
"SIMPLIFY", "")
buff = arcpy.Buffer_analysis(poly, "buff_" + points, "-15 feet",
"FULL", "", "", "")
footprint = arcpy.Erase_analysis(buff, mb, "footprint_" + points, "")
finalRast = arcpy.Clip_management(outIDW, "", "rast_" + points,
footprint, "", "ClippingGeometry")
arcpy.Delete_management(poly)
arcpy.Delete_management(buff)
arcpy.Delete_management(footprint)
else:
outIDW.save(arcpy.Describe(points).catalogPath + out)
def get_stream_order(scratch_gdb, stream_burn_dem, seg_network_a, DEM_orig,
FlowDir, net_raster):
orderMethod = "STRAHLER"
print("running Stream order")
outStreamOrder = StreamOrder(net_raster, FlowDir, orderMethod)
strord_path = scratch_gdb + "/streamord_out"
outStreamOrder.save(strord_path)
print("fixing dodgy first order streams")
str_ras = Raster(strord_path)
Cor_Str_Ord_b = Con(str_ras == 1, 1, str_ras - 1)
Cor_Str_Ord = scratch_gdb + "/Cor_Str_Ord"
Cor_Str_Ord_b.save(Cor_Str_Ord)
max_val = arcpy.GetRasterProperties_management(Cor_Str_Ord, "MAXIMUM")
int_max_val = int(max_val.getOutput(0)) + 1
val_range = list(range(2, int_max_val))
print("expand values to remove 1st order errors")
str_ord_exp = Expand(Cor_Str_Ord, 1, val_range)
str_ord_exp_path = (scratch_gdb + "/str_ord_exp")
str_ord_exp.save(str_ord_exp_path)
print("convert Raster to Polygon")
str_ord_exp_poly = scratch_gdb + "/st_or_ex_poly"
arcpy.RasterToPolygon_conversion(str_ord_exp_path, str_ord_exp_poly,
"NO_SIMPLIFY", "Value")
net_fields = [f.name for f in arcpy.ListFields(seg_network_a)]
if "Str_order" in net_fields:
arcpy.DeleteField_management(seg_network_a, "Str_order")
if "gridcode" in net_fields:
arcpy.DeleteField_management(seg_network_a, "gridcode")
del net_fields
print("join network and StrOrd Polygon fields")
seg_network_b = scratch_gdb + "/seg_network_b"
arcpy.SpatialJoin_analysis(seg_network_a, str_ord_exp_poly, seg_network_b,
"JOIN_ONE_TO_ONE", "KEEP_ALL", "",
"HAVE_THEIR_CENTER_IN")
arcpy.AddField_management(seg_network_b, "Str_order", "SHORT")
with arcpy.da.UpdateCursor(seg_network_b,
["Str_order", "gridcode"]) as cursor:
for row in cursor:
row[0] = row[1]
cursor.updateRow(row)
del row
del cursor
arcpy.DeleteField_management(seg_network_b, "gridcode")
return seg_network_b
def estabFOVfootprint(DEM_raster_layer,Camera_point_layer,Smoothing_Tolerance):
# Spatial Analyst Tools > Surface > Visibility
arcpy.gp.Visibility_sa(DEM_raster_layer,Camera_point_layer,"in_memory\\rawVisRast",\
"","FREQUENCY","NODATA","0.00001201","FLAT_EARTH","0.13","","",\
"OFFSETA","","","AZIMUTH1","AZIMUTH2","VERT1","VERT2")
# Spatial Analyst Tools > Generalization > Boundary Clean
arcpy.gp.BoundaryClean_sa("in_memory\\rawVisRast","in_memory\\clnVisRast","ASCEND","TWO_WAY")
arcpy.Delete_management("in_memory\\rawVisRast")
# Conversion Tools > From Raster > Raster to Polygon
arcpy.RasterToPolygon_conversion("in_memory\\clnVisRast","in_memory\\visPoly","NO_SIMPLIFY","")
arcpy.Delete_management("in_memory\\clnVisRast")
# Cartographic Tools > Generalization > Smooth Polygon
arcpy.SmoothPolygon_cartography("in_memory\\visPoly","in_memory\\smthVisPoly","PAEK",\
Smoothing_Tolerance,"NO_FIXED","NO_CHECK")
arcpy.Delete_management("in_memory\\visPoly")
# Analysis Tools > Overlay > Union
arcpy.Union_analysis("in_memory\\smthVisPoly","in_memory\\uniVisPoly","ALL","","NO_GAPS")
arcpy.Delete_management("in_memory\\smthVisPoly")
# Data Management Tools > Generalization > Dissolve
footprintFOVout = "in_memory\\whlVisPoly"
arcpy.Dissolve_management("in_memory\\uniVisPoly",footprintFOVout,"","",\
"SINGLE_PART","DISSOLVE_LINES")
arcpy.Delete_management("in_memory\\uniVisPoly")
return footprintFOVout
def onClick(self):
arcpy.env.workspace = r"C:\Users\s\Documents\Masters of Geospatial\GISP\Assignment2\GISdata"
# reclassify NIDEM based on user input tide value
# replace tide_height float with a parameter from Tide Height combo box
reclass_values = "-2.601000 {0} 0;{0} 2.772000 1".format(tide_height)
# may need to replace output path with reference to workspace...
if arcpy.Exists("NIDEM_reclass.tif"):
arcpy.Delete_management("NIDEM_reclass.tif")
arcpy.env.overwriteOutput = True # temporarily allow overwriting of exisitng datasets, then disallow.
arcpy.gp.Reclassify_sa(
"NIDEM.tif", "VALUE", reclass_values,
"C:/Users/s/Documents/Masters of Geospatial/GISP/Assignment2/GISdata/NIDEM_reclass.tif",
"DATA")
# RasterToPolygon(in_raster, out_polygon_features, {simplify}, {raster_field}, {create_multipart_features}, {max_vertices_per_feature})
arcpy.RasterToPolygon_conversion("NIDEM_reclass.tif", "zones.shp",
"NO_SIMPLIFY", "VALUE")
# Select(in_features, out_feature_class, {where_clause})
if arcpy.Exists("submerged_extent"):
arcpy.Delete_management("submerged_extent")
arcpy.Select_analysis("zones", "submerged_extent", '"gridcode" = 0')
if arcpy.Exists("exposed_extent"):
arcpy.Delete_management("exposed_extent")
arcpy.Select_analysis("zones", "exposed_extent", '"gridcode" = 1')
arcpy.env.overwriteOutput = False
def onClick(self):
print "Vectorisation de la couche matricielle..."
# Process: Raster to Polygon
arcpy.RasterToPolygon_conversion("cleaned_raster", "vectorized_raster", "NO_SIMPLIFY", "Value")
# Process: Simplify Polygon
arcpy.SimplifyPolygon_cartography("vectorized_raster", "simplified_shoreline", "BEND_SIMPLIFY", "4 Meters",
"10 SquareMeters", "NO_CHECK", "NO_KEEP")
pythonaddins.MessageBox(
"Vectorisation et simplification de la couche matricielle terminé!".decode('utf-8').encode('cp1252'),
"Vectorisation", "0")
real_classes_gc = [[1, u'Vegetation saine'], [2, u'Vegetation fletrie'], [3, u'Sable sec'], [4, u'Sable humide'], [5, u'Laisse de mer']]
with arcpy.da.UpdateCursor("simplified_shoreline", "gridcode") as gcc_cursor:
for row in gcc_cursor:
if row[0] > 0:
for i in Ref_TS_Classes:
for j in real_classes_gc:
if row[0] == i[0]:
temp = i[1]
if j[1] == temp:
row[0] = j[0]
gcc_cursor.updateRow(row)
else:
pass
def Spot_Area_Selection(facilityName):
'''
Select hot or cold spot areas
:param facilityName: feature class name of input
:return:
'''
try:
in_raster = ["Hotspot", "Coldspot"]
Poly = []
Dissolved = []
for i in range(len(in_raster)):
arcpy.RasterToPolygon_conversion(
facilityName + in_raster[i],
facilityName + in_raster[i] + "Poly", "NO_SIMPLIFY")
arcpy.Dissolve_management(
facilityName + in_raster[i] + "Poly",
facilityName + in_raster[i] + "Dissolved")
arcpy.Intersect_analysis(
[facilityName + in_raster[i] + "Dissolved", "basemap_cleaned"],
facilityName + in_raster[i] + "_District")
# Delete feature classes in processing
Poly.append(facilityName + in_raster[i] + "Poly")
Dissolved.append(facilityName + in_raster[i] + "Dissolved")
if arcpy.Exists(Poly[i]): arcpy.Delete_management(Poly[i])
if arcpy.Exists(Dissolved[i]):
arcpy.Delete_management(Dissolved[i])
print("Complete Spot Area Selection!")
except:
print(arcpy.GetMessages())
def run(self):
self.e.load()
print "Starting Creating Facets processing..."
if arcpy.Exists(self.i.cmx): # this forces overwriting the cmx table
arcpy.Delete_management(self.i.cmx)
arcpy.gp.ZonalStatisticsAsTable_sa(self.i.catchment, "HydroID", self.i.fac, self.i.cmx, "DATA", "MAXIMUM")
# --- old code ---
# arcpy.gp.MakeFeatureLayer(self.i.catchment, "lyr")
# arcpy.AddJoin_management("lyr", "HydroID", self.i.cmx, "HydroID", "KEEP_ALL")
# arcpy.SelectLayerByAttribute_management("lyr","NEW_SELECTION","cmx.MAX > cmx.COUNT")
# arcpy.Clip_analysis(self.i.drl, "lyr", self.i.drl_c, "")
# arcpy.SelectLayerByAttribute_management("lyr","NEW_SELECTION","cmx.MAX <= cmx.COUNT") # ESSA PARTE NAO FOI FEITA
# arcpy.Clip_analysis(self.i.lfp, "lyr", self.i.lfp_c, "")
# --- old code ---
self.process_c(self.i.drl, self.i.drl_c)
# self.process_c(self.i.lfp, self.i.lfp_c)
arcpy.Erase_analysis(self.i.drl, self.i.drl_c, self.i.lfp_ct)
arcpy.SpatialJoin_analysis(target_features=self.i.lfp,join_features=self.i.lfp_ct,out_feature_class=self.i.lfp_c,join_operation="JOIN_ONE_TO_ONE",join_type="KEEP_COMMON",match_option="INTERSECT")
arcpy.Merge_management(self.i.drl_c + ";" + self.i.lfp_c, self.i.fm_vec)
arcpy.PolylineToRaster_conversion(self.i.fm_vec, "HydroID", self.i.fm_ras, "MAXIMUM_LENGTH", "NONE", self.e.cs)
arcpy.gp.Divide_sa(self.i.fm_ras, self.i.fm_ras, self.i.fm_ras_d)
arcpy.gp.Reclassify_sa(self.i.fm_ras_d, "VALUE", "1 NODATA;NODATA 0", self.i.fm_ras_r, "DATA")
arcpy.gp.Combine_sa(self.i.fm_ras_r + ";" + self.i.cat, self.i.fm_ras_c)
arcpy.RasterToPolygon_conversion(self.i.fm_ras_c, self.i.facets, "NO_SIMPLIFY", "VALUE")
# --- old code ---
# arcpy.RemoveJoin_management("lyr", "")
# arcpy.SelectLayerByAttribute_management("lyr", "CLEAR_SELECTION", "")
# arcpy.Delete_management("lyr")
# --- old code ---
print "Ending Creating Facets processing..."
def filter_polygon(state, extract_comb):
poly_1 = constants.out_dir + os.sep + state + os.sep + 'poly_1.shp'
poly_2 = constants.out_dir + os.sep + state + os.sep + 'poly_2.shp'
arcpy.RasterToPolygon_conversion(extract_comb, poly_1, "NO_SIMPLIFY",
"VALUE")
arcpy.CalculateAreas_stats(poly_1, poly_2)
def create_boundary(NAME, meter):
input_path = os.path.abspath("input_folder")
output_path = os.path.abspath("output_folder/shp_files")
if os.path.isdir("output_folder/"):
rmtree('output_folder/')
os.mkdir("output_folder/")
os.mkdir("output_folder/shp_files")
else:
os.mkdir("output_folder/")
os.mkdir("output_folder/shp_files")
asc_file_path = os.path.join(input_path, NAME + ".tif")
boundary = os.path.join(output_path, "{}_boundary.shp".format(NAME))
bound_neg2m = os.path.join(output_path, "{}_bound_neg2m.shp".format(NAME))
bound_rec = os.path.join(output_path, "{}_bound_rec.shp".format(NAME))
reclassified = arcpy.sa.Reclassify(
asc_file_path, "VALUE",
"101.102745 105.156837 1;105.156837 108.940979 1")
arcpy.RasterToPolygon_conversion(reclassified, boundary, "NO_SIMPLIFY")
arcpy.Buffer_analysis(boundary, bound_neg2m, "{} Meters".format(meter),
"FULL", "ROUND", "NONE", "",
"PLANAR") # require user input for meters
arcpy.MinimumBoundingGeometry_management(bound_neg2m, bound_rec,
"RECTANGLE_BY_AREA", "NONE", "",
"NO_MBG_FIELDS")
def AreaAndAccuracy(inRaster, inPoly):
rasterPoly = outRaw + "_poly.shp"
rasterPolyarea = 0
lyrPolyarea = 0
testCount = int(arcpy.GetCount_management(testPoints).getOutput(0))
arcpy.RasterToPolygon_conversion(inRaster, rasterPoly, "SIMPLIFY",
"Value")
with arcpy.da.SearchCursor(rasterPoly,
("GRIDCODE", "SHAPE@AREA")) as cursor:
for row in cursor:
if row[0] == 1:
rasterPolyarea += row[1]
with arcpy.da.SearchCursor(inPoly, "SHAPE@AREA") as cursor:
for row in cursor:
lyrPolyarea += row[0]
targetAcres = rasterPolyarea / lyrPolyarea
arcpy.MakeFeatureLayer_management(rasterPoly,
"in_memory\\rasterPoly",
""" "GRIDCODE" = 1 """)
arcpy.MakeFeatureLayer_management(testPoints,
"in_memory\\testPoints")
arcpy.SelectLayerByLocation_management("in_memory\\testPoints",
"WITHIN",
"in_memory\\rasterPoly")
selectCount = int(
arcpy.GetCount_management("in_memory\\testPoints").getOutput(
0))
Accuracy = float(selectCount) / float(testCount)
indexValue = float(Accuracy) / float(targetAcres)
arcpy.AddMessage(
os.path.basename(inRaster) + ": Accuracy = " +
(str(Accuracy)[:5]) + ", Target Area Proportion = " +
(str(targetAcres)[:5]) + ", Index = " + (str(indexValue)[:5]))
arcpy.Delete_management(rasterPoly)
return targetAcres, Accuracy, indexValue
def make_extent_from_dem(dem, output_location):
arcpy.CheckOutExtension("Spatial")
environments = store_environments(["mask", "extent", "outputCoordinateSystem"])
try:
temp_raster_filename = generate_gdb_filename(scratch=True)
dem_properties = arcpy.Describe(dem)
arcpy.env.outputCoordinateSystem = dem_properties.spatialReference # set the spatial reference environment variable so that the constant raster gets created properly
geoprocessing_log.info("Creating Constant Raster")
arcpy.env.mask = dem
raster = arcpy.sa.CreateConstantRaster(constant_value=1, data_type="INTEGER", cell_size=10, extent=dem)
geoprocessing_log.info("Saving to output filename")
print(temp_raster_filename)
raster.save(temp_raster_filename)
geoprocessing_log.info("Converting Raster to Polygon")
arcpy.RasterToPolygon_conversion(temp_raster_filename, output_location, simplify=False, raster_field="Value")
#arcpy.Delete_management(temp_raster_filename)
finally:
arcpy.CheckInExtension("Spatial")
reset_environments(environments)
def RastToShp(rastinfile, year_day, flag):
"""Creates the output extent to be used in the rest of the script. Allows all images to be snapped to
a constant grid, for direct matrix to matrix comparison"""
if flag == 'N':
arcrast = TMP + year_day + "_recasttif.tif"
tmptif = arcpy.Raster(rastinfile)
tmptif.save(arcrast) #This step can be necessary for Arc tools to work properly on .tif files
arcpy.CalculateStatistics_management(arcrast)
if flag == 'Y':
arcrast = TMP + year_day + "_recasttif.tif"
arcpy.CopyRaster_management(rastinfile, arcrast, '', '-9999', '-9999')
arcpy.env.extent = arcrast
clipshp_tmp = TMP + year_day + "_clipshp_tmp.shp"
EXT_data = arcpy.sa.Con(arcrast, 1, 0, '"Value" > 0') #Choose only areas with data
tmp_ext = TMP + year_day + "_clipshp_con.tif"
EXT_data.save(tmp_ext)
del EXT_data
arcpy.RasterToPolygon_conversion(tmp_ext, clipshp_tmp, "NO_SIMPLIFY", "Value") #Convert to Shpfile
clipshp = TMP + year_day + "_ext.shp"
clipshp_tmp2 = TMP + year_day + "_ext_tmp2.shp"
arcpy.Select_analysis(clipshp_tmp, clipshp_tmp2, '"GRIDCODE" = 1')
arcpy.Buffer_analysis(clipshp_tmp2, clipshp, "-2 Kilometers") #Negative buffer to remove edge effects
cliprast = TMP + year_day + '_ext_tif.tif'
arcpy.FeatureToRaster_conversion(clipshp, "GRIDCODE", cliprast, 30) #Convert back to TIF file to use as output extent
arcpy.Delete_management(clipshp)
arcpy.Delete_management(clipshp_tmp)
arcpy.Delete_management(clipshp_tmp2)
arcpy.Delete_management(tmp_ext)
return cliprast, arcrast
def raster_to_polygon(feature,
raster,
scratch,
name=None,
raster_scaling=1000):
"""Convert raster to a features class, clip it to an input feature and
calculate the area of each polygon. This new feature class is then
returned for calculating statistics. """
# Build Export Name. This option is largely included in case there is unexpected
# naming conflicts with other functions
if name == '' or name == None:
polygon = os.path.join(scratch, 'Raster_to_Polygon.shp')
else:
polygon = os.path.join(scratch, name)
# Scale the subset DEM and temporarily save it to file. If it is not
# saved, a VAT error is sometimes thrown when converting to polygon.
subset = spatial.Int(raster * raster_scaling)
converted = arcpy.RasterToPolygon_conversion(subset,
'in_memory\\rtp_result',
'NO_SIMPLIFY')
arcpy.Clip_analysis(converted, feature, polygon)
arcpy.Delete_management(subset)
arcpy.Delete_management(converted)
return polygon
def getEncroachArea(encrType,encrVals,bufferDist,impVals,impType):
arcpy.gp.Reclassify_sa(NLCD_MHB, "Value", encrVals, encrType + "_mhb.tif", "NODATA")
arcpy.RasterToPolygon_conversion(encrType + "_mhb.tif", encrType + "_poly_mhb.shp", "SIMPLIFY", "VALUE")
arcpy.PolygonToLine_management(encrType + "_poly_mhb.shp", encrType + "_edge_mhb.shp", "IGNORE_NEIGHBORS")
arcpy.Buffer_analysis(encrType + "_edge_mhb.shp", encrType + "_" + bufferDist + "m_edge_mhb.shp", bufferDist + " Meters", "FULL", "ROUND", "ALL", "")
arcpy.gp.ExtractByMask_sa(NLCD_MHB, encrType + "_" + bufferDist + "m_edge_mhb.shp", "nlcd_" + encrType + "_" + bufferDist + "m.tif")
arcpy.gp.Reclassify_sa("nlcd_" + encrType + "_" + bufferDist + "m.tif", "VALUE", impVals, impType + "_encroach_" + bufferDist + "m.tif", "NODATA")
def footprint(workspace="C:/workspace",
static_value=1,
mask="C:/data/maskpoly.jpg",
outFootprint="footprint.shp",
outIntRaster="IntRaster.jpg"):
""" calculates the footprint of a raster input.
Procedure: Creating a mask (of input raster), calculating an integer raster,
converting integer raster to polygon, deleting integer raster
"""
try:
arcpy.CheckOutExtension("Spatial")
arcpy.env.workspace = workspace
#set mask
arcpy.env.mask = mask
#compute integer raster and save it
outInt = Int(static_value)
outInt.save(outIntRaster)
#convert integer raster to polygon
arcpy.RasterToPolygon_conversion(outInt, outFootprint, "NO_SIMPLIFY")
#TODO delete processes and int raster
except:
print "Footprint (lokale Funktion -> point2map-library) konnte nicht berechnet werden."
arcpy.AddWarning(
"Footprint (lokale Funktion -> point2map-library) konnte nicht berechnet werden."
)
def CreateUnsuitableSlopes(in_dem, outUnsuitSlope):
arcpy.ProjectRaster_management(in_dem, "project", spatial_ref)
x = arcpy.Describe("project").meanCellWidth
y = arcpy.Describe("project").meanCellHeight
cellSizeXY = "{} {}".format(x, y)
#print(cellSizeXY)
arcpy.Resample_management("project", "resample", cellSizeXY, "CUBIC")
arcpy.Delete_management("project")
# Run slope generation
slope_raster = arcpy.sa.Slope("resample", "PERCENT_RISE")
outInt = arcpy.sa.Int(slope_raster)
arcpy.Delete_management("resample")
del slope_raster
# Set parameters for raster Reclassification as a boolean
max_slope = outInt.maximum
myRemapRange = arcpy.sa.RemapRange([[0, 10, 0], [10, int(max_slope), 1]])
### Run reclassification
outReclassRR = arcpy.sa.Reclassify(outInt, "Value", myRemapRange) #
del outInt
### Query Bad Slopes
#arcpy.ProjectRaster_management(outInt, "project", spatial_ref)
slope_unSuit = arcpy.sa.ExtractByAttributes(outReclassRR, 'Value = 1')
del outReclassRR
## Convert to Vector
arcpy.RasterToPolygon_conversion(slope_unSuit,
outUnsuitSlope,
raster_field="Value")
del slope_unSuit
# Clean up geometry
arcpy.RepairGeometry_management(outUnsuitSlope)
def createComplainRasterFeature(SelectSQL,InputComplainFeatures,POIFeatures,FinalResultFeature):
logging.info("Process: 创建"+FinalResultFeature)
if(arcpy.Exists(FinalResultFeature)):
arcpy.Delete_management(FinalResultFeature, "FeatureClass")
rmNo = random.randint(100000000,999999999)
print rmNo
# Process: 筛选
print "Process: 筛选"
logging.info("Process: 筛选")
FeatureSelect=arcpy.Select_analysis(InputComplainFeatures, "in_memory/FeatureSelect"+repr(rmNo), SelectSQL)
# Process: 点转栅格
print FeatureSelect
rowSear = arcpy.SearchCursor(FeatureSelect)
row = rowSear.next()
if(row):
print "Process: 点转栅格"
logging.info("Process: 点转栅格")
tempEnvironment0 = arcpy.env.extent
arcpy.env.extent = "115 23 122 29"
ResultRaster=arcpy.PointToRaster_conversion(FeatureSelect, "OBJECTID", "in_memory/ResultRaster"+repr(rmNo), "COUNT", "NONE", ".0018")
arcpy.env.extent = tempEnvironment0
# Process: 栅格转点
print "Process: 栅格转点"
logging.info("Process: 栅格转点")
COMPLAIN_RASTER_POINTS=arcpy.RasterToPoint_conversion(ResultRaster, "in_memory/COMPLAIN_RASTER_POINTS"+repr(rmNo), "VALUE")
print "Process: 空间连接"
# Process: 空间连接
COMPLAIN_POI_UNION=arcpy.SpatialJoin_analysis(COMPLAIN_RASTER_POINTS, POI, "in_memory/COMPLAIN_POI_UNION"+repr(rmNo), "JOIN_ONE_TO_ONE", "KEEP_ALL", "","CLOSEST", ".1 DecimalDegrees", "DISTANCE")
print "Process: 点转栅格 (2)"
logging.info("Process: 点转栅格 (2)")
# Process: 点转栅格 (2)
tempEnvironment0 = arcpy.env.extent
arcpy.env.extent = "115 23 122 29"
ResultRaster2=arcpy.PointToRaster_conversion(COMPLAIN_POI_UNION, "OBJECTID", "in_memory/ResultRaster2"+repr(rmNo), "MOST_FREQUENT", "NONE", ".0018")
arcpy.env.extent = tempEnvironment0
print "Process: 栅格转面"
logging.info("Process: 栅格转面")
# Process: 栅格转面
ResultFeature=arcpy.RasterToPolygon_conversion(ResultRaster2, "in_memory/ResultFeature"+repr(rmNo), "NO_SIMPLIFY", "VALUE")
print "Process: 空间连接 (2)"
logging.info("Process: 空间连接 (2)")
# Process: 空间连接 (2)
ResultFeatureZj=arcpy.SpatialJoin_analysis(ResultFeature, COMPLAIN_POI_UNION, "in_memory/ResultFeatureZj"+repr(rmNo), "JOIN_ONE_TO_ONE", "KEEP_ALL", "", "INTERSECT", "", "")
# Process: 空间连接 (3)
arcpy.SpatialJoin_analysis(FeatureSelect, ResultFeatureZj, FinalResultFeature, "JOIN_ONE_TO_ONE", "KEEP_ALL", "", "INTERSECT", "", "")
#arcpy.SpatialJoin_analysis(FeatureSelect, ResultFeatureZj, FinalResultFeature, "JOIN_ONE_TO_ONE", "KEEP_ALL", "TIME \"TIME\" true true false 8 Date 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\GIS_OBJECT_COMPLAIN_Select1,TIME,-1,-1;WORK_ORDER_ID \"WORK_ORDER_ID\" true true false 100 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\GIS_OBJECT_COMPLAIN_Select1,WORK_ORDER_ID,-1,-1;DISTANCE \"DISTANCE\" true true false 8 Double 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,DISTANCE,-1,-1;POINTID \"POINTID\" true true false 4 Long 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,POINTID,-1,-1;GRID_CODE \"聚合数\" true true false 4 Long 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,GRID_CODE,-1,-1;Name \"聚合地址\" true true false 160 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,Name,-1,-1;Ctype \"聚合地址类型(原始)\" true true false 64 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,Ctype,-1,-1;CnType \"聚合地址类型\" true true false 50 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,CnType,-1,-1;CITY \"地市\" true true false 32 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,CITY,-1,-1;COUNTY \"区县\" true true false 32 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,COUNTY,-1,-1;GRID \"GRID\" true true false 32 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,GRID,-1,-1;SGLON \"栅格POI经度\" true true false 8 Double 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,SGLON,-1,-1;SGLAT \"栅格POI纬度\" true true false 8 Double 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,SGLAT,-1,-1;CQ_REGION \"城区网格所属区域\" true true false 60 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,CQ_REGION,-1,-1;CQ_REGION_TYPE \"城区网格区域属性\" true true false 60 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,CQ_REGION_TYPE,-1,-1;TEST_ID \"测试网格ID\" true true false 10 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,TEST_ID,-1,-1;TEST_GRIDID \"测试网格编号\" true true false 20 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,TEST_GRIDID,-1,-1;TEST_CLASS \"测试网格类型\" true true false 10 Text 0 0 ,First,#,D:\\HasmbyGis\\Cache.gdb\\Complain20140509_SpatialJoin,TEST_CLASS,-1,-1", "INTERSECT", "", "")
arcpy.Delete_management(COMPLAIN_POI_UNION)
arcpy.Delete_management(COMPLAIN_RASTER_POINTS)
arcpy.Delete_management(ResultRaster)
arcpy.Delete_management(ResultRaster2)
arcpy.Delete_management(ResultFeature)
arcpy.Delete_management(ResultFeatureZj)
del COMPLAIN_POI_UNION,COMPLAIN_RASTER_POINTS,ResultRaster,ResultRaster2,ResultFeature,ResultFeatureZj
arcpy.Delete_management(FeatureSelect)
del FeatureSelect,rowSear
logging.info("清理内存~~")
gc.collect()
def run(self):
self.e.load()
print "Starting Facet Classification processing..."
arcpy.gp.Times_sa(self.i.sdg_f, 0, self.i.empty)
arcpy.gp.ZonalGeometry_sa(self.i.facets, self.Zone_field,
self.i.facet_a, "AREA", self.i.empty)
arcpy.gp.Int_sa(self.i.empty, self.i.empty_i)
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.facet_a,
self.i.facet_mn_a, "MINIMUM", "DATA")
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.facet_a,
self.i.facet_mx_a, "MAXIMUM", "DATA")
self.process_facet_a_r()
arcpy.gp.ZonalStatistics_sa(self.i.facets, self.Zone_field,
self.i.sdg_f, self.i.m_slp, "MEAN", "DATA")
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.m_slp,
self.i.m_slp_mn, "MINIMUM", "DATA")
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.m_slp,
self.i.m_slp_mx, "MAXIMUM", "DATA")
self.process_m_slp_r()
arcpy.gp.ZonalStatistics_sa(self.i.facets, self.Zone_field, self.e.d,
self.i.m_d, "MEAN", "DATA")
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.m_d,
self.i.m_d_mn, "MINIMUM", "DATA")
arcpy.gp.ZonalStatistics_sa(self.i.empty_i, "VALUE", self.i.m_d,
self.i.m_d_mx, "MAXIMUM", "DATA")
self.process_m_d_r()
print "Please wait...",
if sleep(180) == None:
self.e.load()
print "Processing algorithm...",
inputs = ";".join([
self.i.m_slp_r, self.i.m_d_r
]) # only rasters zoned by facets can be entered here
arcpy.gp.IsoClusterUnsupervisedClassification_sa(
self.i.m_slp_r, self.Number_of_classes, self.i.fc,
self.Minimum_class_size, self.Sample_interval, self.i.sig)
arcpy.RasterToPolygon_conversion(self.i.fc, self.i.fc_shp,
"NO_SIMPLIFY", "VALUE")
print "Dissolving...",
arcpy.Dissolve_management(self.i.fc_shp, self.i.fc_shp_d,
"GRIDCODE", "", "MULTI_PART",
"DISSOLVE_LINES")
print "Joining features..."
# Now it is a point feature
# instead of a polygon one.
# This was modified in 11/30/2019
arcpy.SpatialJoin_analysis(target_features=self.e.s,
join_features=self.i.fc_shp_d,
out_feature_class=self.i.fc_shp_osj,
join_operation="JOIN_ONE_TO_MANY",
join_type="KEEP_ALL",
match_option="INTERSECT",
search_radius="#",
distance_field_name="#")
# arcpy.SpatialJoin_analysis(target_features=self.i.fc_shp_d, join_features=self.e.s, out_feature_class=self.i.fc_shp_osj, join_operation="JOIN_ONE_TO_ONE", join_type="KEEP_ALL", match_option="CLOSEST",search_radius="5000", distance_field_name="#") # modified match_option="INTERSECT" in 06/15/2019 to "CLOSEST"
print "Ending Facet Classification processing..."
def floodplain(slop_dem, colorivers):
# jeff_dem_slop = sa.Raster(r"D:\Deliverable\source_data\dem_utm_120mclip_aspectslope.tif")
dem = r"D:\Deliverable\source_data\dem_utm_120mclip.tif"
jeff_dem_ras = sa.Raster(dem)
llpnt2 = jeff_dem_ras.extent.lowerLeft
demSize2 = jeff_dem_ras.meanCellHeight
slop_Arr = arcpy.RasterToNumPyArray(slop_dem)
slop_Arr[slop_Arr <= 0] = 0
flat_grid = np.where((slop_Arr <= 25.0),1,0)
flatRaster = arcpy.NumPyArrayToRaster(flat_grid,llpnt2,demSize2,demSize2)
# steepRaster = arcpy.NumPyArrayToRaster(steep_grid,llpnt,demSize,demSize)
#
arcpy.Delete_management("flat_FP")
arcpy.DefineProjection_management(flatRaster,jeff_dem_ras.spatialReference)
flatRaster.save('flat_FP')
# floodplain(jeff_dem, colorivers)
ZST = ZonalStatisticsAsTable(r"D:\Deliverable\source_data\intersect_dem", "PIN", r"D:\Deliverable\flat_fp",
r"D:\Deliverable\ZST_fp_dem", "NODATA", "Maximum")
# 7. Perform final joins so that suitability output raster has correct parcel data
#----------------------------------------------------------------------------------------------
inFeatures = r"D:\Deliverable\source_data\intersect_dem"
joinField = "PIN"
joinTable = r"D:\Deliverable\ZST_fp_dem"
fieldList = ["MAX"]
# Join two feature classes by the zonecode field and only carry over the land use and land cover fields
arcpy.JoinField_management(inFeatures, joinField, joinTable, joinField,
fieldList)
arcpy.RasterToPolygon_conversion(r"D:\Deliverable\source_data\intersect_dem", r"D:\Deliverable\source_data\intersect_dem"+".shp", "NO_SIMPLIFY", "MAX")
inter_steep = r"D:\Deliverable\source_data\inter_steep.shp"
inter_shp = r"D:\Deliverable\source_data\intersect_dem.shp"
agri = """"gridcode" = 0 """
arcpy.Select_analysis(inter_shp, inter_steep,agri)
inter_flat = r"D:\Deliverable\source_data\inter_flat.shp"
inter_shp = r"D:\Deliverable\source_data\intersect_dem.shp"
agri = """"gridcode" = 1 """
arcpy.Select_analysis(inter_shp, inter_flat,agri )
arcpy.Clip_analysis(colorivers, inter_flat, r"D:\Deliverable\flatClip2.shp")
arcpy.Clip_analysis(colorivers, inter_steep, r"D:\Deliverable\steepClip2.shp")
arcpy.Delete_management("flatBuff")
arcpy.Buffer_analysis(r"D:\Deliverable\flatClip2.shp", "flatBuff", "400 meters")
arcpy.Delete_management("steepBuff")
arcpy.Buffer_analysis(r"D:\Deliverable\steepClip2.shp", "steepBuff", "150 meters")
def createViewshed(self):
try:
tempEnvironment0 = arcpy.env.extent
arcpy.env.extent = self.buffer
tempEnvironment1 = arcpy.env.cellSize
arcpy.env.cellSize = self.cellsize
arcpy.AddMessage("cellsize: " + str(arcpy.env.cellSize))
tempEnvironment2 = arcpy.env.mask
arcpy.env.mask = self.buffer
#outraster = sa.Viewshed(self.islyr, self.obsproc, 1, "FLAT_EARTH", 0.13)
outraster = sa.Visibility(self.islyr,
self.obsproc,
analysis_type="FREQUENCY",
nonvisible_cell_value="ZERO",
z_factor=1,
curvature_correction="CURVED_EARTH",
refractivity_coefficient=0.13,
observer_offset=self.height,
outer_radius=self.radius,
vertical_upper_angle=90,
vertical_lower_angle=-90)
#outrastertemp = os.path.join(r"C:\GEE\visibility", 'outvis')
#outraster.save(outrastertemp)
vshedtmp = os.path.join("in_memory", 'vshedtmp')
vsheddis = os.path.join("in_memory", 'vsheddis')
#vshed_proj = os.path.join(self.scratchgdb, 'vshedproj')
arcpy.AddMessage("temp vshed fc:" + vshedtmp)
arcpy.AddMessage("dissolved vshed fc: " + vsheddis)
arcpy.env.extent = tempEnvironment0
arcpy.env.cellSize = tempEnvironment1
arcpy.env.mask = tempEnvironment2
arcpy.RasterToPolygon_conversion(outraster, vshedtmp,
"NO_SIMPLIFY", "VALUE")
arcpy.Dissolve_management(vshedtmp, vsheddis, "gridcode", "",
"MULTI_PART", "DISSOLVE_LINES")
## if(self.wkidproc != self.wkidout):
## arcpy.AddMessage("Projecting output vshed...")
## arcpy.AddMessage("projected vshed fc: " + vshed_proj)
## arcpy.Project_management(vsheddis, vshed_proj, self.srOut)
## vshed=vshed_proj
## else:
## vshed=vsheddis
#vistmp = os.path.join('in_memory', 'visibility')
vis = os.path.join(self.scratchgdb, 'visibility')
arcpy.AddMessage('creating output viewshed: ' + vis)
arcpy.Clip_analysis(vsheddis, self.mask, vis, "")
arcpy.AddMessage("Coppying to output...")
#arcpy.CopyFeatures_management(vistmp, vis)
fset = arcpy.FeatureSet()
fset.load(vis)
return fset
except arcpy.ExecuteError:
EH = ErrorHandling.ErrorHandling()
line, filename, err = EH.trace()
m = "Python error on " + line + " of " + __file__ + \
" : with error - " + err
arcpy.AddError(m)
def mu_maker(self, h_raster, u_raster, full_out_ras_name,
full_out_shp_name, *mu):
# h_raster: STR - full path to depth raster
# u_raster: STR - full path to velocity raster
# full_out_ras_name: STR - full path of the results raster name
# full_out_shp_name: STR - full path of the result shapefile name
# mu = LIST(STR) - (optional) - restricts analysis to a list of morphological units according to mu.xlsx
# start with raster calculations
self.logger.info("Raster Processing --- --- ")
self.license_state = arcpy.CheckOutExtension(
'Spatial') # check out license
arcpy.gp.overwriteOutput = True
arcpy.env.workspace = self.path
arcpy.env.extent = "MAXOF"
try:
self.mu_names = mu[
0] # limit mu analysis to optional list, if provided
except:
pass
out_ras = self.calculate_mu(h_raster, u_raster)
try:
self.logger.info(" > Saving Raster ...")
out_ras.save(full_out_ras_name)
self.logger.info(" * OK")
except:
self.logger.info("ERROR: Could not save MU raster.")
arcpy.CheckInExtension('Spatial') # release license
self.logger.info("Raster Processing OK --- \n")
self.logger.info("Shapefile Processing --- --- ")
self.logger.info(" > Converting mu raster to shapefile ...")
temporary_shp = full_out_shp_name.split(".shp")[0] + "1.shp"
arcpy.RasterToPolygon_conversion(arcpy.Raster(full_out_ras_name),
temporary_shp, 'NO_SIMPLIFY')
self.logger.info(" > Calculating Polygon areas ...")
arcpy.CalculateAreas_stats(temporary_shp, full_out_shp_name)
self.logger.info(" * OK - Removing remainders ...")
arcpy.Delete_management(temporary_shp)
self.logger.info(" > Adding MU field ...")
arcpy.AddField_management(full_out_shp_name,
"MorphUnit",
"TEXT",
field_length=50)
expression = "the_dict[!gridcode!]"
codeblock = "the_dict = " + str(
dict(
zip(self.mu_names_number.values(),
self.mu_names_number.keys())))
arcpy.CalculateField_management(full_out_shp_name, "MorphUnit",
expression, "PYTHON", codeblock)
self.logger.info("Shapefile Processing OK --- ")
def raster_overlap(file_A, file_B, outpath, NoData_A=None, NoData_B=None):
"""
Finds overlaping area between two raster images.
this function examines two images and outputs a raster identifying pixels where both
rasters have non-NoData values. Output raster has 1's where both images have data and
0's where one or both images are missing data.
inputs:
file_A the first file
file_B the second file
outpath the output filename for the desired output. must end in ".tif"
NoData_A the NoData value of file A
NoData_B the NoData value of file B
This function automatically invokes
clip_and_snap
null_define
"""
if not is_rast(file_A) or not is_rast(file_B):
raise Exception(' both inputs must be rasters!')
# load the rasters as numpy arays.
a, metaA = to_numpy(file_A)
b, metaB = to_numpy(file_B)
# set no_datas
if NoData_A is None:
NoData_A = metaA.NoData_Value
if NoData_B is None:
NoData_B = metaB.NoData_Value
# spatially match the rasters
print('preparing input rasters!')
clip_and_snap(file_A, file_B, outpath.replace(".shp", ".tif"), NoData_B)
# reload the rasters as numpy arrays now that spatial matching is done
a, metaA = to_numpy(file_A)
b, metaB = to_numpy(file_B)
# create work matrix and find the overlap
print('Finding overlaping pixels!')
Workmatrix = a.mask + b.mask
Workmatrix = Workmatrix.astype('uint8')
Workmatrix[Workmatrix == 1] = 2
print('Saving overlap file!')
metaA.numpy_datatype = 'uint8'
from_numpy(Workmatrix,
metaA,
outpath.replace(".shp", ".tif"),
NoData_Value=2)
arcpy.RasterToPolygon_conversion(outpath.replace(".shp", ".tif"),
outpath.replace(".tif", ".shp"),
'NO_SIMPLIFY')
return metaA, metaB
def krigingFromPointCSV(inTable, valueField, xField, yField, inClipFc, workspace = "assignment3.gdb"):
#import arcpy and os and set overwriteOutput to true
import arcpy
import os
arcpy.env.overwriteOutput = True
#set the workspace to be the geodatabase that is provided
arcpy.env.workspace = geodatabase
#map out the X and Y points from a table
arcpy.management.XYTableToPoint(inTable, "year", xField, yField)
#.Describe to find the features of the year dataset
desc= arcpy.Describe("year")
#set variable cellsize to 0
CellSize= 0
#set the width and the height to the .extent width and height
width = desc.extent.width
height= desc.extent.height
#if the width is smaller it divded by 1000 is the cellsize, else the height divided by 1000 is the cell size
if width < height:
CellSize = width / 1000
else:
CellSize = height / 1000
#set a variable for the output name
field = "F2018_PREC"
#preform the Kriging on the dataset and save it as F2018k
outKriging = Kriging("year, field, '#', CellSize)
outKriging.save("F2018k")
#.Describe the clip feature class to find it's extent then set variable rectangle to be equal to it's extent information
descClip = arcpy.Describe(inClipFc)
rectangle = str(descClip.extent.XMin) + " " + str(descClip.extent.YMin) + " " + str(descClip.extent.XMax) + " " + str(descClip.extent.YMax)
#clip the raster
arcpy.Clip_management(outKriging, rectangle, "F2018KC", inClipFc, "#", "ClippingGeometry", "MAINTAIN_EXTENT" )
#change to an integer from a floating point raster
outInt = Int("F2018KC")
outInt.save("F2018KCI")
#find the min and max values of the outInt
min_F2018 = arcpy.management.GetRasterProperties(outInt, "MINIMUM")
max_F2018 = arcpy.management.GetRasterProperties(outInt, "MAXIMUM")
#set a variable with the number of classes
numofclasses = 5
#find the class range for equal interval breaks
eq_interval = (int(max_F2018.getOutput(0)) - int(min_F2018.getOutput(0))) / numofclasses
print(eq_interval)
#set an empty list
remapRangeList = []
mybreak = int(min_F2018.getOutput(0))
#the following for loop populates the list with the lower bound, upper bound, and the class number for each of the 5 classes
for t in range(0, numofclasses):
newClassCode = t + 1
lowerBound = mybreak
upperbound = mybreak + eq_interval
remap = [lowerBound, upperbound, newClassCode]
remapRangeList.append(remap)
mybreak += eq_interval
#reclassify the raster into an isarithmic map based on the remapRangeList
outReclassRR = Reclassify("F2018KCI", "Value", RemapRange(remapRangeList), "NODATA")
outReclassRR.save("F2018_CL")
#convert to polygon
arcpy.RasterToPolygon_conversion("F2018_CL", "F2018_ismc")
def vectorize(georef_mask):
basename = os.path.splitext(os.path.basename(georef_mask))[0]
os.makedirs(resources.temp_vectorized, exist_ok=True)
vectorized = os.path.join(resources.temp_vectorized,
"{}.shp".format(basename))
field = "VALUE"
arcpy.RasterToPolygon_conversion(georef_mask, vectorized,
"NO_SIMPLIFY", field)
return vectorized
