def createYun():
StopOrStartService(serviceFolder, "DynamicGSMRasterHW", "stop")
StopOrStartService(serviceFolder, "DynamicGSMRasterLL", "stop")
if (arcpy.Exists(CellThiessYunHW)):
arcpy.Delete_management(CellThiessYunHW)
if (arcpy.Exists(CellThiessYunLL)):
arcpy.Delete_management(CellThiessYunLL)
logging.info("PolygonToRaster_conversion HW")
print "面转栅格"
# Process: 面转栅格
arcpy.PolygonToRaster_conversion(CellThiessFinal, "VOICE_TOTAL_TRAFFIC",
CellThiessYunHW, "CELL_CENTER", "NONE",
".01")
logging.info("CalculateStatistics_management HW")
print "计算统计数据"
# Process: 计算统计数据
arcpy.CalculateStatistics_management(CellThiessYunHW, "1", "1", "",
"OVERWRITE", "")
logging.info("PolygonToRaster_conversion LL")
arcpy.PolygonToRaster_conversion(CellThiessFinal, "UL_DL_FLOW",
CellThiessYunLL, "CELL_CENTER", "NONE",
".01")
logging.info("CalculateStatistics_management LL")
print "计算统计数据"
# Process: 计算统计数据
arcpy.CalculateStatistics_management(CellThiessYunLL, "1", "1", "",
"OVERWRITE", "")
StopOrStartService(serviceFolder, "DynamicGSMRasterHW", "start")
StopOrStartService(serviceFolder, "DynamicGSMRasterLL", "start")
def set_project_area(self, geofile_name):
# geofile_name = STR of either project area shapefile or TIF raster (DO NOT PROVIDE ANY FILE ENDING [SHP / TIF])
self.logger.info(" * looking up project area polygon from " +
str(geofile_name) + " ...")
self.set_env()
arcpy.env.workspace = self.dir2geo + "Rasters\\"
raster_list = arcpy.ListRasters()
project_raster_exists = False
for ras in raster_list:
if geofile_name.lower() in str(ras).lower():
try:
self.ras_project = arcpy.Raster(self.dir2geo +
"Rasters\\" +
str(ras).lower())
project_raster_exists = True
self.logger.info(" * found project area Raster: " +
str(ras).lower())
except:
self.logger.info(
"ERROR: Could not load existing Raster of the project area."
)
if not project_raster_exists:
self.logger.info(" * Polygon to Raster conversion required.")
shp_project = self.dir2geo + "Shapefiles\\" + geofile_name.lower(
) + ".shp"
try:
self.logger.info(
" * converting project area Polygon (%s) to Raster ... "
% shp_project)
try:
arcpy.PolygonToRaster_conversion(
shp_project, "gridcode", self.dir2geo + "Rasters\\" +
geofile_name.lower() + ".tif")
except:
arcpy.PolygonToRaster_conversion(
shp_project, "AreaCode", self.dir2geo + "Rasters\\" +
geofile_name.lower() + ".tif")
self.logger.info(" ok")
except:
self.logger.info(
"ERROR: Could not create Raster of the project area.")
try:
self.ras_project = arcpy.Raster(self.dir2geo + "Rasters\\" +
str(geofile_name) + ".tif")
except:
try:
self.ras_project = arcpy.Raster(self.dir2geo +
"Rasters\\" +
str(geofile_name).lower() +
".tif")
except:
self.logger.info(
"ERROR: Could not load newly created Raster of the project area."
)
arcpy.env.workspace = self.cache
def feature2Raster(inFeatureClass, referenceRaster, landslide=False):
# inRasters must be as dictionary {path:'',valueField:'',name:''}
refRaster = arcpy.Raster(referenceRaster)
arcpy.env.extent = refRaster.extent
arcpy.env.snapRaster = refRaster
outRaster = r"d:\Personal\Temp\{}".format(inFeatureClass['name'])
if (landslide):
colFields = arcpy.ListFields(inFeatureClass['path'])
if (inFeatureClass['classField'].upper() not in [
x.name.upper()
for x in arcpy.ListFields(inFeatureClass['path'])
]):
arcpy.AddField_management(inFeatureClass['path'],
field_name="{}".format(
inFeatureClass['classField']),
field_type="SHORT")
with arcpy.da.UpdateCursor(
inFeatureClass['path'],
field_names=["{}".format(inFeatureClass['classField'])
]) as cursor:
for row in cursor:
row[0] = 1
cursor.updateRow(row)
arcpy.PolygonToRaster_conversion(inFeatureClass['path'],
value_field="{}".format(
inFeatureClass['classField']),
out_rasterdataset=outRaster,
cellsize=refRaster.meanCellWidth)
out = {}
out['noData'] = arcpy.Raster(outRaster).noDataValue
out['path'] = outRaster
out['classField'] = inFeatureClass['classField']
out['name'] = inFeatureClass['name']
return out
else:
try:
arcpy.PolygonToRaster_conversion(inFeatureClass['path'],
value_field="{}".format(
inFeatureClass['classField']),
out_rasterdataset=outRaster,
cellsize=refRaster.meanCellWidth)
except:
print('Eroare')
print(arcpy.GetMessages(2))
out = {}
out['noData'] = arcpy.Raster(outRaster).noDataValue
out['path'] = outRaster
out['classField'] = inFeatureClass['classField']
out['name'] = inFeatureClass['name']
# print('NoData: ', arcpy.Raster(outRaster).noDataValue)
return out
def findFlowAccumulation(flowAccumulation, tempData, cellSize):
"""
Finds the flow accumulation at the point defined in the findPrecipitation function
:param flowAccumulation: A raster containing flow accumulation data
:param tempData: Where we can dump all our intermediary data points
:param cellSize: The area of each cell
:return: Flow accumulation at a point
"""
try:
arcpy.Buffer_analysis(tempData + "\point.shp",
tempData + "\pointBuffer.shp", "20 Meters")
arcpy.PolygonToRaster_conversion(tempData + "\pointBuffer.shp",
"FID",
tempData + "\pointBufferRaster.tif",
cellsize=sqrt(cellSize))
maxFlow = arcpy.sa.ZonalStatistics(tempData + "\pointBufferRaster.tif",
"Value", flowAccumulation,
"MAXIMUM")
arcpy.sa.ExtractValuesToPoints(tempData + "\point.shp", maxFlow,
tempData + "\\flowPoint")
except:
return -9999
searchCursor = arcpy.da.SearchCursor(tempData + "\\flowPoint.shp",
"RASTERVALU")
row = searchCursor.next()
flowAccAtPoint = row[0]
del row
del searchCursor
flowAccAtPoint *= cellSize # gives us the total area of flow accumulation, rather than just the number of cells
flowAccAtPoint /= 1000000 # converts from square meters to square kilometers
if flowAccAtPoint < 0:
flowAccAtPoint = 0
return flowAccAtPoint
def convertMapUnitsToRaster(projectGDB, mapUnits, season, cellSize):
# Select features of specified subtype
util.ClearSelectedFeatures(mapUnits)
feature = arcpy.MakeFeatureLayer_management(mapUnits, "lyr")
fields = ["Winter", "Breed", "Summer"]
for field in fields:
where_clause = "NOT {0} IS NULL".format(
arcpy.AddFieldDelimiters(feature, field)
)
arcpy.SelectLayerByAttribute_management(feature,
"ADD_TO_SELECTION",
where_clause)
# Count features selected to ensure >0 feature selected
test = arcpy.GetCount_management(mapUnits)
count = int(test.getOutput(0))
# Convert to raster
if count > 0:
in_features = mapUnits
value_field = season
out_rasterdataset = os.path.join(
projectGDB, season + "_Site_Quality")
cell_assignment = "MAXIMUM_AREA"
priority_field = season
arcpy.PolygonToRaster_conversion(in_features,
value_field,
out_rasterdataset,
cell_assignment,
priority_field,
cellSize)
return out_rasterdataset
def estimate2012pop(popRast2010Path, outGDB, outDir, iso3):
arcpy.CheckOutExtension("Spatial")
old_workspace = arcpy.env.workspace
old_scratchWorkspace = arcpy.env.scratchWorkspace
tmpdir = tempfile.mkdtemp()
arcpy.env.workspace = tmpdir
arcpy.env.scratchWorkspace = tmpdir
try:
# Get raster cell size
popRast2010 = arcpy.Raster(popRast2010Path)
cellSize = (popRast2010.meanCellHeight + popRast2010.meanCellWidth) / float(2)
# Create raster of growth rates from feature class
arcpy.PolygonToRaster_conversion(outGDB + "/growthRates%s" % iso3,
"Growth20102015",
"growth20102015.tif",
cell_assignment="MAXIMUM_AREA",
cellsize=cellSize)
pop2012 = popRast2010 * arcpy.sa.Exp(arcpy.Raster("growth20102015.tif") / 100 * 2)
arcpy.CopyRaster_management(pop2012, os.path.join(outDir, "%s2012unadjustedPop.tif" % iso3), pixel_type="32_BIT_FLOAT")
finally:
arcpy.Delete_management("in_memory")
arcpy.Delete_management(tmpdir)
arcpy.env.workspace = old_workspace
arcpy.env.scratchWorkspace = old_scratchWorkspace
arcpy.CheckInExtension("Spatial")
def coastaldem(Input_Workspace, grdNamePth, InFeatureClass, OutRaster, seaLevel, version = None):
'''Sets elevations for water and other areas in digital elevation model.
Parameters
----------
Input_Workspace : str
Input workspace, output raster will be written to this location.
grdNamePth : str
Path to the input DEM grid.
InFeatureClass : str
Path to the LandSea feature class.
OutRaster : str
Output DEM grid name.
seaLevel : float
Elevation at which to make the sea.
version : str (optional)
StreamStats Data Preparation Tools version number
Returns
-------
OutRaster : raster
Output raster with coastal areas corrected.
Notes
-----
Outputs are written to the workspace.
'''
if version:
arcpy.AddMessage('StreamStats Data Preparation Tools version: %s'%(version))
try:
# set working folder
arcpy.env.workspace = Input_Workspace
arcpy.env.scratchWorkspace = arcpy.env.workspace
arcpy.env.extent = grdNamePth
arcpy.env.snapRaster = grdNamePth
arcpy.env.outputCoordinateSystem = grdNamePth
arcpy.env.cellSize = grdNamePth
# this is assuming land is 1 and sea is -1
arcpy.PolygonToRaster_conversion(InFeatureClass, "Land", "mskg")
mskg = Raster("mskg") # load the mask grid
grdName = Raster(grdNamePth) # load the
seag = Con(mskg == -1, float(seaLevel))
landg = Con((mskg == 1) & (grdName <= 0), 1, grdName)
nochgg = Con(mskg == 0, grdName)
arcpy.MosaicToNewRaster_management([seag,landg,nochgg],arcpy.env.workspace,OutRaster,None, "32_BIT_SIGNED", None, 1, "FIRST") # mosaic and produce new raster
except:
e = sys.exc_info()[1]
print(e.args[0])
arcpy.AddError(e.args[0])
return None
def disthistory(inlayer, distfield, outlayer, fire=False):
# set environment settings
arcpy.env.snapRaster = "Y:/Tahoe/GISdata/Lattice_Clip30m.gdb/Lattice_Clip30m_ProjBound"
arcpy.env.extent = "Y:/Tahoe/GISdata/Lattice_Clip30m.gdb/Lattice_Clip30m_ProjBound"
arcpy.env.workspace = "Y:/Tahoe/GISdata/WorkGDBCreated051214.gdb/"
arcpy.AddField_management(inlayer, "DisturbanceYear", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(inlayer, "Age_2010", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
print "added fields"
arcpy.CalculateField_management(inlayer, "DisturbanceYear", "".join(["int(!",distfield,"!)"]), "PYTHON", "")
print "calc field 1 done"
arcpy.CalculateField_management(inlayer, "Age_2010", "2010 - !DisturbanceYear!", "PYTHON", "")
print "calc field 2 done"
if fire:
rule = "\"BEST_ASSESS\" = 'YES' AND \"BURNSEV\" = 4"
arcpy.SelectLayerByAttribute_management(inlayer, "NEW_SELECTION", rule)
print "selected layer"
# Set local variables
assignmentType = "MAXIMUM_AREA"
cellSize = "30"
arcpy.PolygonToRaster_conversion(inlayer, "Age_2010", outlayer, assignmentType, "NONE", cellSize)
print "conversion successful"
def prep_idp_dataset():
# Local variables
ipd = orig_datasets_path + "\\CII\\DVRPC_2016_Indicators_of_Potential_Disadvantage\\DVRPC_2016_Indicators_of_Potential_Disadvantage.shp"
ipd_clipped = "ipd_clipped"
ipd_ras = "ipd_ras"
ipd_score_ras = "ipd_score_ras"
# Load the feature class into the MXD
arcpy.MakeFeatureLayer_management(ipd, "idp")
# NO need to reproject (already in NAD 1983 UTM Zone 18N)
# Clip to the boundaries of 4_counties_dissolved
arcpy.SpatialJoin_analysis(ipd, "extent_4_counties", ipd_clipped,
"JOIN_ONE_TO_ONE", "KEEP_COMMON", match_option="HAVE_THEIR_CENTER_IN")
# Convert into a raster
arcpy.PolygonToRaster_conversion (ipd_clipped, "IPD_Score", ipd_ras)
# reclassify the raster to 1-to-20 score using the Jenks natural breaks classification
arcpy.CheckOutExtension("Spatial")
outslice = arcpy.sa.Slice(ipd_ras, 20, "NATURAL_BREAKS")
outslice.save(ipd_score_ras)
# Display the resulting raster (note that the tool demands a slightly different name for the layer)
arcpy.MakeRasterLayer_management(ipd_score_ras, "ipd_score_ras1")
# Cleanup
remove_intermediary_layers(["idp","ipd_clipped", "ipd_ras"])
def _clip_data(self, dem, intersect):
"""
Clip input data based on AOI.
:param str dem: raster DTM name
:param str intersect: vector intersect feature call name
:return str dem_clip: output clipped DTM name
"""
if self.data['points']:
self.data['points'] = self._clip_points(intersect)
# set extent from intersect vector map
arcpy.env.extent = intersect
# raster description
dem_desc = arcpy.Describe(dem)
# output raster coordinate system
arcpy.env.outputCoordinateSystem = dem_desc.SpatialReference
# create raster mask based on intersect feature call
mask = self.storage.output_filepath('inter_mask')
arcpy.PolygonToRaster_conversion(intersect,
self.storage.primary_key,
mask,
"MAXIMUM_AREA",
cellsize=dem_desc.MeanCellHeight)
# cropping rasters
dem_clip = ExtractByMask(dem, mask)
dem_clip.save(self.storage.output_filepath('dem_inter'))
return dem_clip
def multi_convert_to_raster(polygon_fc_list, output_workspace):
for polygon_fc in polygon_fc_list:
env.extent = polygon_fc
env.snapRaster = SNAP_RASTER
short_name = os.path.splitext(os.path.basename(polygon_fc))[0]
arcpy.AddMessage("Converting {}...".format(short_name))
output_raster = os.path.join(output_workspace, short_name + '_raster')
lagoslakeid_field = arcpy.ListFields(polygon_fc,
'*lagoslakeid')[0].name
zoneid_field = arcpy.ListFields(polygon_fc, '*zoneid')[0].name
if lagoslakeid_field:
zone_field = lagoslakeid_field
else:
zone_field = zoneid_field
output_raster = arcpy.PolygonToRaster_conversion(polygon_fc,
zone_field,
output_raster,
'CELL_CENTER',
cellsize=CELL_SIZE)
arcpy.BuildPyramids_management(output_raster, SKIP_FIRST=True)
if lagoslakeid_field:
arcpy.BuildRasterAttributeTable_management(output_raster, True)
arcpy.AddField_management(output_raster, 'lagoslakeid', 'LONG')
arcpy.CalculateField_management(output_raster, 'lagoslakeid',
'!Value!', 'PYTHON_9.3')
arcpy.AddMessage("Completed.")
def shp_to_rst(shp, inField, cellsize, outRaster, template=None, snap=None):
"""
Feature Class to Raster
"""
if template:
tempEnvironment0 = arcpy.env.extent
arcpy.env.extent = template
if snap:
tempSnap = arcpy.env.snapRaster
arcpy.env.snapRaster = snap
obj_describe = arcpy.Describe(shp)
geom = obj_describe.ShapeType
if geom == 'Polygon':
arcpy.PolygonToRaster_conversion(shp, inField, outRaster,
"CELL_CENTER", "NONE", str(cellsize))
elif geom == 'Polyline':
arcpy.PolylineToRaster_conversion(shp, inField, outRaster,
"MAXIMUM_LENGTH", "NONE",
str(cellsize))
if template:
arcpy.env.extent = tempEnvironment0
if snap:
arcpy.env.snapRaster = tempSnap
def clip_raster_box(in_raster, clip_feature, out_raster):
"""Clip raster to a feature"""
in_proj = arcpy.Describe(in_raster).spatialReference
clip_proj = arcpy.Describe(clip_feature).spatialReference
tmp = None
clip_with = clip_feature
if in_proj.exporttostring() != clip_proj.exporttostring():
tmp = project(clip_with,
arcpy.CreateScratchName(),
projection=arcpy.Describe(in_raster).spatialReference)
# project the clipping features to the input features projection so clip works
clip_with = tmp
env_push()
env_defaults(mask="", extent="", cellSize=in_raster)
oldSpatial = arcpy.env.outputCoordinateSystem
arcpy.env.outputCoordinateSystem = arcpy.Describe(
in_raster).spatialReference
clipBuffer = calc(
"ClipBuffer", lambda _: arcpy.PolygonToRaster_conversion(
clip_with,
arcpy.ListFields(clip_with)[0].name, _))
#~ clipBuffer = calc("ClipBuffer", lambda _: CreateConstantRaster(0, extent=clip_with))
out_raster = calc(out_raster,
lambda _: Con(IsNull(clipBuffer), clipBuffer, in_raster))
arcpy.Delete_management(clipBuffer)
arcpy.env.outputCoordinateSystem = oldSpatial
env_pop()
if tmp:
# assuming this is simple enough that deleting every time makes sense
arcpy.Delete_management(tmp)
return out_raster
def compute_zonal(MFgrid, DEM, z_conversion_factor=1, outfile=None):
# Settings
output_path = os.path.split(MFgrid)[0]
arcpy.env.workspace = output_path
arcpy.env.overwriteOutput = True
arcpy.env.qualifiedFieldNames = False
# Check out any necessary licenses
arcpy.CheckOutExtension("spatial")
#arcpy.AddField_management(MFgrid,"cellnum","LONG") #isn't needed if there is a node column
print "multipling DEM z-values by %s to convert units..." %(z_conversion_factor)
DEM2 = arcpy.sa.Raster(DEM)*z_conversion_factor
print "extracting model top elevations from DEM..."
# create raster of gridcells based on node (cellnum)
# run zonal statistics on DEM for each grid cell
print "\tbuilding raster of model grid cells for sampling DEM..."
DEMres = arcpy.GetRasterProperties_management(DEM2, "CELLSIZEX")
DEMres = float(DEMres.getOutput(0)) # cell size of DEM in project units
arcpy.PolygonToRaster_conversion(MFgrid, "node", os.path.join(output_path, "MFgrid_raster"), "MAXIMUM_AREA", "node", DEMres)
print "\tbuilding raster attribute table..."
arcpy.BuildRasterAttributeTable_management(os.path.join(output_path, "MFgrid_raster"))
print "\trunning zonal statistics... (this step will likely take several minutes or more)"
arcpy.sa.ZonalStatisticsAsTable(os.path.join(output_path, "MFgrid_raster"), "VALUE", DEM2, os.path.join(output_path, "demzstats.dbf"), "DATA", "ALL")
print "joining elevations back to model grid cells..."
arcpy.MakeFeatureLayer_management(MFgrid, "MFgrid")
if not outfile:
outfile = os.path.join(output_path, MFgrid[:-4]+'_elevs.shp')
general_join(outfile, "MFgrid", "node", os.path.join(output_path, "demzstats.dbf"), "VALUE", True)
def polygon_to_raster(infc, outlocation, snapRaster, inlocation):
start_conversion = datetime.datetime.now()
# set environmental variables
arcpy.env.workspace = outlocation
arcpy.Delete_management("snap")
arcpy.MakeRasterLayer_management(snapRaster, "snap")
arcpy.env.snapRaster = "snap"
# Set local variables
inFeatures = inlocation + os.sep + infc
valField = "Zone"
outRaster = outlocation + os.sep + infc
assignmentType = "CELL_CENTER"
cellSize = snapRaster
print inFeatures
arcpy.Delete_management("fc_lyr")
arcpy.MakeFeatureLayer_management(inFeatures, "fc_lyr")
# Execute PolygonToRaster
if not arcpy.Exists(outRaster):
arcpy.PolygonToRaster_conversion("fc_lyr", valField, outRaster, assignmentType, "NONE", cellSize)
print "\nCompleted conversion of {0} in {1}".format(outRaster, (datetime.datetime.now() - start_conversion))
else:
print "\nAlready completed conversion {0}".format(outRaster)
arcpy.Delete_management("snap")
def execute(self, parameters, messages):
'''The source code of the tool.'''
in_rasterdataset = parameters[0].valueAsText
in_fc = parameters[1].valueAsText
in_cellsize = parameters[2].valueAsText
in_field = parameters[3].valueAsText
arcpy.env.workspace = in_rasterdataset
## check workspace and raster files
rasterlist = arcpy.ListRasters("*")
arcpy.PolygonToRaster_conversion(in_features=in_fc,
value_field=in_field,
out_rasterdataset="snap1",
cellsize=in_cellsize)
snap = "snap1"
arcpy.AddMessage("Snap Raster Created")
## Project, resample, and clip rasters
for raster in rasterlist:
Ras = arcpy.Raster(raster)
arcpy.env.snapRaster = snap
projrast1 = arcpy.ProjectRaster_management(Ras, "proj1", snap,
"NEAREST")
resamprast1 = arcpy.Resample_management(projrast1, "resamp1",
in_cellsize, "NEAREST")
cliprast = arcpy.Clip_management(resamprast1, "#",
raster + "_final", in_fc, "0",
"ClippingGeometry")
arcpy.AddMessage("Snap Raster Created")
## Delete temp files
arcpy.Delete_management("resamp1")
arcpy.Delete_management("proj1")
def Landslides2Raster(self, landslides_feature, reference_raster, mask):
landslidesOUT = "in_memory\\lSimR"
arcpy.env.snapRaster = reference_raster
arcpy.env.extent = reference_raster.extent
# arcpy.FeatureToRaster_conversion(landslides, "tobia", landslidesOUT, cell_size=referenceRaster.meanCellWidth)
arcpy.PolygonToRaster_conversion(landslides_feature, "SIM", out_rasterdataset=landslidesOUT, cellsize=reference_raster.meanCellWidth)
arcpy.SetRasterProperties_management(landslidesOUT, nodata=[[1, 0]])
return arcpy.Raster(landslidesOUT) * mask
def main():
""" DOC STRING """
# Make Feature Layers
arcpy.MakeFeatureLayer_management(
INPUTDATA.MAPPING_METHOD_POLYGON, # in_features
MAPPING_METHOD_LAYER_1, # out_layer
"\"100Bry_ele\" <> 0", # where_clause
"", # workspace
FIELD_ARGS)
arcpy.MakeFeatureLayer_management(INPUTDATA.MAPPING_METHOD_POLYGON,
MAPPING_METHOD_LAYER_2,
"\"VAGut_ele\" <> 0", "", FIELD_ARGS)
arcpy.MakeFeatureLayer_management(INPUTDATA.MAPPING_METHOD_POLYGON,
MAPPING_METHOD_LAYER_3,
"\"LIMWA_ele\" <> 0", "", FIELD_ARGS)
# Convert Polygons to Rasters
arcpy.PolygonToRaster_conversion(MAPPING_METHOD_LAYER_1, "100Bry_ele",
V100_YR_RAS, "CELL_CENTER", "NONE", "25")
arcpy.PolygonToRaster_conversion(MAPPING_METHOD_LAYER_2, "VAGut_ele",
VA_RAS, "CELL_CENTER", "NONE", "25")
arcpy.PolygonToRaster_conversion(MAPPING_METHOD_LAYER_3, "LIMWA_ele",
LIMWA_RAS, "CELL_CENTER", "NONE", "25")
# Convert Rasters to TINs
arcpy.RasterTin_3d(V100_YR_RAS, V100_YR_TIN, "0.01", "1500000", "1")
arcpy.RasterTin_3d(VA_RAS, VA_TIN, "0.01", "1500000", "1")
arcpy.RasterTin_3d(LIMWA_RAS, LIMWA_TIN, "0.01", "1500000", "1")
# Calculate Surface Difference new TINs vs. TERRAIN
arcpy.SurfaceDifference_3d(V100_YR_TIN, INPUTDATA.TERRAIN,
V100_YR_SURF_DIFF_SHP, "0", "0",
OUTPUT_RASTER_1, "10", "", "")
arcpy.SurfaceDifference_3d(VA_TIN, INPUTDATA.TERRAIN, VA_SURF_DIFF_SHP,
"0", "0", OUTPUT_RASTER_2, "10", "", "")
arcpy.SurfaceDifference_3d(LIMWA_TIN, INPUTDATA.TERRAIN,
LIMWA_SURF_DIFF_SHP, "0", "0", OUTPUT_RASTER_3,
"10", "", "")
# Process: Polygon To Line
arcpy.PolygonToLine_management(V100_YR_SURF_DIFF_SHP,
V100_YR_RUNUP_BDY_SHP, "IDENTIFY_NEIGHBORS")
arcpy.PolygonToLine_management(VA_SURF_DIFF_SHP, VA_BDY_SHP,
"IDENTIFY_NEIGHBORS")
arcpy.PolygonToLine_management(LIMWA_SURF_DIFF_SHP, LIMWA_BDY_SHP,
"IDENTIFY_NEIGHBORS")
def Polygon2Raster(plg, cellsize, extent, raster, isprint):
#GRIDCODE=1
arcpy.env.extent = extent
arcpy.env.snapRaster = extent
arcpy.PolygonToRaster_conversion(plg, "GRIDCODE", raster, "CELL_CENTER",
"NONE", cellsize)
if isprint:
print('Polygon2Raster is finished....')
def land_use(nlcd_layer, search_area, excluded_types, tiger_lines,
census_places, crs, workspace):
arcpy.CheckOutExtension("spatial")
geoprocessing_log.info("Extracting NLCD raster to search area")
nlcd_in_area = arcpy.sa.ExtractByMask(nlcd_layer, search_area)
avoid_types = [exclude.value for exclude in excluded_types]
thresholded_raster = nlcd_in_area
for avoid in avoid_types: # this is inefficient, but I couldn't get it to work with a "not in" and I need something that works for n number of values
thresholded_raster = arcpy.sa.Con(thresholded_raster != avoid,
thresholded_raster, 0)
scratch_raster = generate_gdb_filename("temp_raster", scratch=True)
thresholded_raster.save(
scratch_raster) # save it so we can use it for environment variables
stored_environments = store_environments(
('cellSize', 'mask', 'extent', 'snapRaster')
) # cache the env vars so we can reset them at the end of this function
arcpy.env.cellSize = scratch_raster
arcpy.env.mask = scratch_raster
arcpy.env.extent = scratch_raster
arcpy.env.snapRaster = scratch_raster
roads_mask = make_road_mask(tiger_lines,
census_places=census_places,
search_area=search_area)
roads_raster = generate_gdb_filename("roads_raster")
geoprocessing_log.info("Converting roads mask to raster")
try:
arcpy.PolygonToRaster_conversion(roads_mask, "OBJECTID", roads_raster)
#arcpy.CalculateStatistics_management(roads_raster) # crashes for invalid statistics unless we run this after the conversion
except:
geoprocessing_log.error(
"Error creating raster: {0:s} - from roads mask: {1:s}".format(
roads_raster, roads_mask))
raise
# Raster Calculations
final_nlcd = arcpy.sa.Con(arcpy.sa.IsNull(arcpy.sa.Raster(roads_raster)),
thresholded_raster, 1)
intermediate_raster = generate_gdb_filename("intermediate_nlcd_mask")
projected_raster = generate_gdb_filename("projected_nlcd_mask",
gdb=workspace)
final_nlcd.save(intermediate_raster)
reset_environments(stored_environments)
geoprocessing_log.info("Reprojecting final raster")
arcpy.ProjectRaster_management(intermediate_raster,
projected_raster,
out_coor_system=crs)
filtered_nlcd_poly = filter_patches.convert_and_filter_by_code(
projected_raster, filter_value=0)
return filtered_nlcd_poly
def ShpToRaster(fileRoot, item, timeItem, type):
arcpy.PolygonToRaster_conversion(
fileRoot + '\\' + 'shapefile' + '_' + str(resolution) + '\\' + type +
'_' + timeItem + '_' + str(resolution) + '\\' + item,
"FID",
fileRoot + '\\' + 'raster' + '_' + str(resolution) + '\\' + type +
'_' + timeItem + '_' + str(resolution) + '\\' + item.split('.')[0] +
'.tif',
cellsize=0.00054)
def getRelevantRaster(inDir, bufferSize, outAllR, DEM):
#print "time %s - computing relevant raster" % (time.strftime("%m%d_%H%M%S"))
zdrojDir = config.zdrojDir
SA = config.getSA(DEM)
sourceDEM = config.getSourceDEM(DEM)
rasterDEM = zdrojDir + SA + "\\" + sourceDEM + "\\" + DEM
tempWS = config.temp
demDirs = [tempWS]
createDEMdirs(inDir, demDirs)
cellSize = bufferSize
# list of rasters to merge
tiffNames = []
# for each lineaments according to DEM
shp_listDir = os.listdir(inDir)
for shpName in shp_listDir:
if shpName[-4:] == ".shp":
inSHP = inDir + shpName
angleStart = shpName.find("_") + 1
angleEnd = shpName.find("_", angleStart)
rotateAngle = shpName[shpName.rfind("_") + 1:-4]
outLineName = shpName[0:angleEnd] + "_" + rotateAngle
outLineR = "in_memory\\" + outLineName
outLineB = "in_memory\\" + outLineName + "B"
# buffer inSHP
lineSHPBuffName = shpName[:-4] + "_buff%d" % bufferSize
lineSHPBuff = "in_memory\\" + lineSHPBuffName
if not os.path.exists(lineSHPBuff):
arcpy.Buffer_analysis(inSHP, lineSHPBuff,
"%d Meters" % bufferSize, "FULL",
"ROUND", "NONE", "#")
if not os.path.exists(outLineB):
# create filed, fill with 1 in order to convert vector to raster
myField = "binary"
myValue = 1
# COMPUTING WITH BUFFER instead of line
inSHP = lineSHPBuff
arcpy.AddField_management(inSHP, myField, "SHORT", 2, "", "",
"", "NULLABLE", "NON_REQUIRED")
arcpy.CalculateField_management(inSHP, myField, myValue,
"PYTHON_9.3", "#")
# polyline to raster, use this field
if not os.path.exists(outLineR):
desc = arcpy.Describe(rasterDEM)
arcpy.env.extent = desc.extent
arcpy.PolygonToRaster_conversion(inSHP, myField, outLineR,
"CELL_CENTER", "NONE",
cellSize)
arcpy.env.extent = "default"
try:
# reclassify NoData to 0 !
arcpy.gp.Reclassify_sa(outLineR, "VALUE", "1 1;NODATA 0",
outLineB, "DATA")
tiffNames.append(outLineB)
except Exception, e:
print e
arcpy.Delete_management(outLineR)
arcpy.Delete_management(lineSHPBuff)
def convert_polygon_to_raster(workspace_gdb, in_feature, value,
out_raster_name):
print("executing convert polygon to raster...")
output_path = os.path.join(workspace_gdb, out_raster_name)
output_raster = arcpy.PolygonToRaster_conversion(in_feature, value,
output_path).getOutput(0)
print("created output raster at {0}".format(output_raster))
print("finished processing conversion")
return output_raster
def convert_shp2raster(self, shapefile):
cov_raster = "cov_ras.tif" # name of the temporarily used cover raster
try:
arcpy.PolygonToRaster_conversion(shapefile, "cover", self.cache + cov_raster,
cell_assignment="CELL_CENTER", priority_field="NONE", cellsize=1)
except:
self.logger.info(
"ERROR: Could not perform polygon to raster conversion for: (" + shapefile + ").")
return arcpy.Raster(self.cache + cov_raster)
def convertProposedToRasterDebit(ProposedSurfaceDisturbance, cellSize):
arcpy.AddMessage("Preparing Proposed Surface Disturbance for processing")
# Check feature type of provided feature class
desc = arcpy.Describe(ProposedSurfaceDisturbance)
# Make feature layer of proposed surface disturbance
features = arcpy.MakeFeatureLayer_management(ProposedSurfaceDisturbance, "lyr")
# Generate list of unique subtypes in Proposed_Surface_Disturbance
uniqueProposedSubtypes = list(set([row[0] for row in arcpy.da.SearchCursor(
ProposedSurfaceDisturbance, "Subtype")]))
arcpy.AddMessage("Proposed Surface Disturbance contains "
+ str(uniqueProposedSubtypes))
for subtype in uniqueProposedSubtypes:
# Select features of specified subtype
field = "Subtype"
where_clause = """{} = '{}'""".format(arcpy.AddFieldDelimiters
(features, field), subtype)
arcpy.SelectLayerByAttribute_management(features,
"NEW_SELECTION",
where_clause)
# Count features selected to ensure >0 feature selected
test = arcpy.GetCount_management(features)
count = int(test.getOutput(0))
# Convert to raster
if count > 0:
in_features = features
value_field = "Weight"
out_rasterdataset = os.path.join("Proposed_" + subtype)
cell_assignment = "MAXIMUM_AREA"
priority_field = "Weight"
if desc.shapeType == "Polygon":
arcpy.PolygonToRaster_conversion(in_features,
value_field,
out_rasterdataset,
cell_assignment,
priority_field,
cellSize)
else: # Consider changing to buffer of ? meters
arcpy.FeatureToRaster_conversion(in_features,
value_field,
out_rasterdataset,
cellSize)
# Clear selected features
arcpy.SelectLayerByAttribute_management(features,
"CLEAR_SELECTION")
return uniqueProposedSubtypes
def create_patches(self):
"""Creates a patch for each separate stranding pool"""
# reclassify q_disc ras to ints
self.logger.info("Creating rating curve fit patches...")
int_ras = Reclassify(self.q_disc_ras, 'Value', RemapValue(list(zip(self.discharges, range(len(self.discharges))))))
# convert to polygon
patch_poly = os.path.join(self.cache, 'patches.shp')
arcpy.RasterToPolygon_conversion(int_ras, patch_poly, 'NO_SIMPLIFY')
# convert back to raster, with unique val for each patch
self.patch_ras = os.path.join(self.cache, 'patches.tif')
arcpy.PolygonToRaster_conversion(patch_poly, 'FID', self.patch_ras)
def execute_BridgeCorrection(r_dem,
str_bridges,
str_result,
messages,
language="FR"):
with arcpy.EnvManager(snapRaster=r_dem):
with arcpy.EnvManager(extent=r_dem):
linebridges = arcpy.CreateScratchName(
"lines",
data_type="FeatureClass",
workspace=arcpy.env.scratchWorkspace)
arcpy.PolygonToLine_management(str_bridges, linebridges,
"IGNORE_NEIGHBORS")
r_linebridges = arcpy.CreateScratchName(
"rlines",
data_type="RasterDataset",
workspace=arcpy.env.scratchWorkspace)
arcpy.PolylineToRaster_conversion(linebridges,
"ORIG_FID",
r_linebridges,
cellsize=r_dem)
r_polybridges = arcpy.CreateScratchName(
"rpoly",
data_type="RasterDataset",
workspace=arcpy.env.scratchWorkspace)
arcpy.PolygonToRaster_conversion(
str_bridges,
arcpy.Describe(str_bridges).OIDFieldName,
r_polybridges,
cellsize=r_dem)
r_bridges = arcpy.sa.Con(
arcpy.sa.IsNull(r_polybridges) == 1, r_linebridges,
r_polybridges)
z_bridges = arcpy.sa.ZonalStatistics(r_bridges, "VALUE", r_dem,
"MINIMUM")
temp_isnull = arcpy.sa.IsNull(z_bridges)
temp_dem = arcpy.sa.Con(temp_isnull, z_bridges, r_dem, "VALUE = 0")
temp_fill = arcpy.sa.Fill(temp_dem)
result = arcpy.sa.Con(temp_isnull, temp_fill, r_dem, "VALUE = 0")
result.save(str_result)
arcpy.Delete_management(linebridges)
arcpy.Delete_management(r_linebridges)
def convert_ras(in_huc, in_bf, in_strm):
if in_bf:
arcpy.AddMessage("Preparing the stream network...")
arcpy.MakeFeatureLayer_management(in_strm, r"in_strm_lyr")
arcpy.MakeFeatureLayer_management(in_bf, r"in_bf_lyr")
arcpy.Clip_analysis("in_strm_lyr", in_huc, r"in_memory\strm_clip")
arcpy.Clip_analysis("in_bf_lyr", in_huc, r"in_memory\bf_clip")
arcpy.MakeFeatureLayer_management(r"in_memory\strm_clip",
"strm_clip_lyr")
arcpy.MakeFeatureLayer_management(r"in_memory\bf_clip", "bf_clip_lyr")
cellSize = arcpy.env.cellSize
# convert streams to a raster format
arcpy.AddField_management("strm_clip_lyr", "VAL", "SHORT")
arcpy.CalculateField_management("strm_clip_lyr", "VAL", "1",
"PYTHON_9.3")
arcpy.PolylineToRaster_conversion("strm_clip_lyr", "VAL",
r"in_memory\strm_ras", "", "",
cellSize)
# convert bankful polygon
arcpy.AddField_management("bf_clip_lyr", "VAL", "SHORT")
arcpy.CalculateField_management("bf_clip_lyr", "VAL", "1",
"PYTHON_9.3")
arcpy.PolygonToRaster_conversion("bf_clip_lyr", "VAL",
r"in_memory\bf_ras", "CELL_CENTER",
"", cellSize)
# Mosaic stream and bankful rasters
strm_final = arcpy.MosaicToNewRaster_management(
r"in_memory\bf_ras;in_memory\strm_ras", "in_memory", "strmMSC", "",
"8_BIT_UNSIGNED", cellSize, 1, "LAST", "")
return strm_final
else:
arcpy.AddMessage("Preparing the stream network...")
arcpy.MakeFeatureLayer_management(in_strm, r"in_strm_lyr")
arcpy.Clip_analysis("in_strm_lyr", in_huc, r"in_memory\strm_clip")
arcpy.MakeFeatureLayer_management(r"in_memory\strm_clip",
"strm_clip_lyr")
#cellSize = arcpy.env.cellSize
# convert streams to a raster format
arcpy.AddField_management("strm_clip_lyr", "VAL", "SHORT")
arcpy.CalculateField_management("strm_clip_lyr", "VAL", "1",
"PYTHON_9.3")
strm_final = arcpy.PolylineToRaster_conversion(
"strm_clip_lyr", "VAL", r"in_memory\strm_final")
return strm_final
def calcConiferPost(coniferTreatmentArea, Conifer_Cover):
arcpy.AddMessage("Calculating post-project conifer modifier")
# Add field Conifer to use when converting to raster
inTable = coniferTreatmentArea
fieldName = "Conifer"
fieldType = "SHORT"
expression = 0
arcpy.AddField_management(inTable, fieldName, fieldType)
arcpy.CalculateField_management(inTable, fieldName, expression,
"PYTHON_9.3", "")
# Convert to raster
in_features = coniferTreatmentArea
value_field = "Conifer"
out_rasterdataset = "Proposed_Conifer_Cover"
cell_assignment = "MAXIMUM_AREA"
priority_field = "Conifer"
cellSize = 30
coniferRaster = arcpy.PolygonToRaster_conversion(in_features,
value_field,
out_rasterdataset,
cell_assignment,
priority_field,
cellSize)
# Mask existing conifer cover
coniferPost = Con(IsNull(coniferRaster), Conifer_Cover, coniferRaster)
coniferPost.save("Post_Conifer_Cover")
# Calculate neighborhood statistics
in_raster = coniferPost
radius = 400
neighborhood = NbrCircle(radius, "MAP")
statistics_type = "MEAN"
coniferCover400 = FocalStatistics(in_raster, neighborhood, statistics_type)
# Reclassify to get Post_Conifer_Modifier
in_raster = coniferCover400
reclass_field = "VALUE"
remapTable = [[0, 1, 100], [1, 2, 28], [2, 3, 14], [3, 4, 9], [4, 5, 6],
[5, 7, 3], [7, 8, 2], [8, 9, 1], [9, 100, 0]]
coniferModifierPost100 = Reclassify(in_raster, reclass_field,
RemapRange(remapTable))
coniferModifierPost = Float(coniferModifierPost100) / 100
return coniferModifierPost
def buildPointGrids(inFeature, tempRaster, cell_size, outShapefile):
# Convert from polygon to raster and raster to point to create point grid
arcpy.PolygonToRaster_conversion(inFeature, "OBJECTID", tempRaster, "CELL_CENTER", "NONE", cell_size)
# Determine if raster contains only NoData values
noData = int(arcpy.GetRasterProperties_management(tempRaster, 'ALLNODATA')[0])
if noData == 0:
# Convert raster to point grid
arcpy.RasterToPoint_conversion(tempRaster, outShapefile, "VALUE")
# Add XY Coordinates to feature class in the NAD_1983_Alaska_Albers projection
arcpy.AddXY_management(outShapefile)
# Delete intermediate files
arcpy.Delete_management(tempRaster)
elif noData == 1:
arcpy.AddMessage("All values for this watershed are nodata...")
# Delete intermediate files
arcpy.Delete_management(tempRaster)
