else:
if all_files_in_directory == 1:
FCE_Spp = arcpy.ListRasters("FCE*", "tif")
CCE_Spp = arcpy.ListRasters("CCE*", "tif")
if len(subset_of_CEs) > 0:
FCE_Spp = FCE_Spp[subset_of_CEs[0]:subset_of_CEs[1]]
CCE_Spp = CCE_Spp[subset_of_CEs[0]:subset_of_CEs[1]]
else:
CCE_Spp = ['CCE0220.tif'] #for lanai cce0003, cce0055
FCE_Spp = ['FCE0220.tif']
#Filter CO points to island only
if island != 'all':
island_mask = "%s%s/DEM/%s_extent.tif" % (landscape_factor_dir, island,
island)
island_mask = arcpy.Raster(island_mask)
#LOAD AUXILIARY LAYERS
#veg_zone_layer="%sVegetation Zones1.tif" %(landscape_factor_dir)
veg_zone_layer = "%sveg_zones2" % (landscape_factor_dir)
veg_zone_layer = arcpy.Raster(veg_zone_layer)
veg_types_layer = "%slandfire_reclass_wetland_coastal_UTM_8b.tif" % (
landscape_factor_dir)
veg_types_layer = arcpy.Raster(veg_types_layer)
#CO_data=r"%scorrected_CO_data2_merged_and_filtered.shp" %(CAO_data_dir) #corrected_CO_dataXY
CO_data = r"%scorrected_CO_data4_merged_and_filtered.shp" % (
CAO_data_dir) #corrected_CO_dataXY
arcpy.MakeFeatureLayer_management(CO_data, "CO_lyr")
def execute_RunSim_prev_2var(str_zonefolder, str_simfolder, str_lisfloodfolder, str_csvq, str_csvz, voutput, simtime, channelmanning, r_zbed, str_log, messages):
str_inbci = str_zonefolder + "\\inbci.shp"
str_outbci = str_zonefolder + "\\outbci.shp"
zbed = RasterIO(r_zbed)
bcipointcursor = arcpy.da.SearchCursor(str_inbci, ["SHAPE@", "zoneid", "flowacc", "type", "fpid"])
dictsegmentsin = {}
for point in bcipointcursor:
if point[1] not in dictsegmentsin:
dictsegmentsin[point[1]] = []
dictsegmentsin[point[1]].append(point)
allzones = list(dictsegmentsin.keys())
allzones.sort()
dictzones_fp = {}
for zone in allzones:
if dictsegmentsin[zone][0][4] not in dictzones_fp:
dictzones_fp[dictsegmentsin[zone][0][4]] = []
dictzones_fp[dictsegmentsin[zone][0][4]].append(zone)
sortedzones = []
listfp = list(dictzones_fp.keys())
listfp.sort()
for fp in listfp:
listzones_fp = dictzones_fp[fp]
listzones_fp.sort(reverse=True)
sortedzones.extend(listzones_fp)
# Ajout des information du fichier outbci.shp
listzonesout = {}
bcipointcursor = arcpy.da.SearchCursor(str_outbci, ["zoneid", "side", "lim1", "lim2", "side2", "lim3", "lim4", "SHAPE@"])
for point in bcipointcursor:
listzonesout[point[0]] = point
zones = str_zonefolder + "\\envelopezones.shp"
# récupération du bci lac
zonesscursor = arcpy.da.SearchCursor(zones, ["GRID_CODE", "SHAPE@", "Lake_ID"])
lakeid_byzone = {}
for zoneshp in zonesscursor:
if zoneshp[2] != -999:
lakeid_byzone[zoneshp[0]] = zoneshp[2]
filelog = open(str_log, 'w')
csvfilez = open(str_csvz)
csv_readerz = csv.DictReader(csvfilez)
ref_raster = None
for csvzrow in csv_readerz:
zname = csvzrow["nom"]
hfix = float(csvzrow["z"])
csvfileq = open(str_csvq)
csv_readerq = csv.DictReader(csvfileq)
for csvqrow in csv_readerq:
simname = csvqrow["nom"] + "_" + zname
currentsimfolder = str_simfolder + "\\" + simname
currentresult = str_simfolder + "\\res_" + simname
simq = float(csvqrow["q"])
if not os.path.isdir(currentsimfolder):
os.makedirs(currentsimfolder)
for zone in sortedzones:
segment = dictsegmentsin[zone]
for point in sorted(segment, key=lambda q: q[2]):
if point[3]=="main":
try:
if not arcpy.Exists(currentsimfolder + "\\elev_zone" + str(point[1])):
if ref_raster is None:
ref_raster = arcpy.Raster(str_zonefolder + "\\zone" + str(point[1]))
outpointshape = listzonesout[point[1]][7].firstPoint
if arcpy.Exists(currentresult):
# dans le cas où un fichier résultat existe avec un résulat valide, on prends les résultats de ce fichier comme limite aval
if arcpy.Exists(currentsimfolder + "\\tmp_zone" + str(point[1])):
arcpy.Delete_management(currentsimfolder + "\\tmp_zone" + str(point[1]))
arcpy.Copy_management(currentresult, currentsimfolder + "\\tmp_zone" + str(point[1]))
res_downstream = RasterIO(arcpy.Raster(currentsimfolder + "\\tmp_zone" + str(point[1])))
hfix_raster = res_downstream.getValue(res_downstream.YtoRow(outpointshape.Y),
res_downstream.XtoCol(outpointshape.X))
if hfix_raster != res_downstream.nodata:
hfix_sim = hfix_raster
else:
hfix_sim = hfix
arcpy.Delete_management(currentsimfolder + "\\tmp_zone" + str(point[1]))
else:
hfix_sim = hfix
# par
newfile = str_simfolder + "\\zone" + str(point[1]) + ".par"
if os.path.isfile(newfile):
os.remove(newfile)
filepar = open(newfile, 'w')
filepar.write("DEMfile\tzone" + str(point[1]) + ".txt\n")
filepar.write("resroot\tzone" + str(point[1]) + "\n")
filepar.write("dirroot\t" + simname + "\n")
filepar.write("manningfile\tnzone" + str(point[1]) + ".txt\n")
filepar.write("bcifile\tzone" + str(point[1]) + ".bci" + "\n")
filepar.write("sim_time\t" + str(simtime) + "\n")
filepar.write("saveint\t" + str(simtime) + "\n")
filepar.write("bdyfile\t"+ simname +"\\zone" + str(point[1]) + ".bdy" + "\n")
filepar.write("SGCwidth\twzone" + str(point[1]) + ".txt\n")
filepar.write("SGCbank\tzone" + str(point[1]) + ".txt\n")
filepar.write("SGCbed\tdzone" + str(point[1]) + ".txt\n")
filepar.write("SGCn\t" + str(channelmanning) + "\n")
filepar.write("chanmask\tmzone" + str(point[1]) + ".txt\n")
# Vitesses du courant
if voutput:
filepar.write("hazard\n")
filepar.write("qoutput\n")
filepar.write("cfl\t0.3\n")
filepar.write("max_Froude\t1\n")
# filepar.write("debug\n")
filepar.close()
# bdy
newfilebdy = currentsimfolder + "\\zone" + str(point[1]) + ".bdy"
for point2 in sorted(segment, key=lambda q: q[2]):
q_value = point2[2]*simq*(ref_raster.meanCellHeight*ref_raster.meanCellWidth)/1000000.
if point2[3] == "main":
# Création du fichier bdy
pointdischarge = q_value / (
(ref_raster.meanCellHeight + ref_raster.meanCellWidth) / 2)
lastdischarge = q_value
latnum = 0
filebdy = open(newfilebdy, 'w')
filebdy.write("zone"+str(point[1]) + ".bdy\n")
filebdy.write("zone"+str(point[1]) + "\n")
filebdy.write("3\tseconds\n")
filebdy.write("0\t0\n")
filebdy.write("{0:.3f}".format(pointdischarge) + "\t50000\n")
filebdy.write("{0:.3f}".format(pointdischarge) + "\t" + str(simtime))
filebdy.close()
else:
latnum += 1
pointdischarge = (q_value - lastdischarge) / (
(ref_raster.meanCellHeight + ref_raster.meanCellWidth) / 2)
lastdischarge = q_value
filebdy = open(newfilebdy, 'a')
filebdy.write("\nzone" + str(point[1]) + "_" + str(latnum) + "\n")
filebdy.write("3\tseconds\n")
filebdy.write("0\t0\n")
filebdy.write("{0:.3f}".format(pointdischarge) + "\t50000\n")
filebdy.write("{0:.3f}".format(pointdischarge) + "\t" + str(simtime))
filebdy.close()
# condition aval: 30cm au dessus du lit pour commencer
zdep = min(zbed.getValue(zbed.YtoRow(outpointshape.Y),
zbed.XtoCol(outpointshape.X)) + 0.3, hfix_sim)
filebdy = open(newfilebdy, 'a')
filebdy.write("\nhvar\n")
filebdy.write("4\tseconds\n")
filebdy.write("{0:.2f}".format(zdep) + "\t0\n")
filebdy.write("{0:.2f}".format(zdep) + "\t50000\n")
filebdy.write("{0:.2f}".format(hfix_sim) + "\t55000\n")
filebdy.write("{0:.2f}".format(hfix_sim) + "\t" + str(simtime))
filebdy.close()
# calcul pour le -steadytol
# Divise le débit par 200 et ne conserve qu'un chiffre significatif
steadytol = str(
round(lastdischarge / 200., - int(math.floor(math.log10(abs(lastdischarge / 200.))))))
subprocess.check_call([str_lisfloodfolder + "\\lisflood_intelRelease_double.exe", "-steady", "-steadytol", steadytol, str_simfolder + "\\zone" + str(point[1]) + ".par"], shell=True, cwd=str_simfolder)
# Conversion des fichiers output
# on renomme les fichiers créés (nécessaire pour être acceptés par l'outil de convsersion ASCII vers raster)
zonename = "zone"+str(point[1])
if os.path.exists(currentsimfolder + "\\" + zonename + "elev.txt"):
os.remove(currentsimfolder + "\\" + zonename + "elev.txt")
if os.path.exists(currentsimfolder + "\\" + zonename + "-9999.elev"):
os.rename(currentsimfolder + "\\" + zonename + "-9999.elev",
currentsimfolder + "\\" + zonename + "elev.txt")
else:
os.rename(currentsimfolder + "\\" + zonename + "-0001.elev",
currentsimfolder + "\\" + zonename + "elev.txt")
filelog.write("Steady state not reached : " + zonename + ", sim " + simname)
messages.addWarningMessage("Steady state not reached : " + zonename + ", sim " + simname)
if os.path.exists(currentsimfolder + "\\" + zonename + "-9999.Vx") or os.path.exists(currentsimfolder + "\\" + zonename + "-0001.Vx"):
if os.path.exists(currentsimfolder + "\\" + zonename + "Vx.txt"):
os.remove(currentsimfolder + "\\" + zonename + "Vx.txt")
if os.path.exists(currentsimfolder + "\\" + zonename + "Vy.txt"):
os.remove(currentsimfolder + "\\" + zonename + "Vy.txt")
if os.path.exists(currentsimfolder + "\\" + zonename + "-9999.Vx"):
os.rename(currentsimfolder + "\\" + zonename + "-9999.Vx",
currentsimfolder+ "\\" + zonename + "Vx.txt")
os.rename(currentsimfolder + "\\" + zonename + "-9999.Vy",
currentsimfolder + "\\" + zonename + "Vy.txt")
else:
os.rename(currentsimfolder + "\\" + zonename + "-0001.Vx",
currentsimfolder + "\\" + zonename + "Vx.txt")
os.rename(currentsimfolder + "\\" + zonename + "-0001.Vy",
currentsimfolder + "\\" + zonename + "Vy.txt")
arcpy.ASCIIToRaster_conversion(currentsimfolder + "\\" + zonename + "Vx.txt",
currentsimfolder + "\\Vx_" + zonename,
"FLOAT")
arcpy.ASCIIToRaster_conversion(currentsimfolder + "\\" + zonename + "Vy.txt",
currentsimfolder + "\\Vy_" + zonename,
"FLOAT")
arcpy.DefineProjection_management(currentsimfolder + "\\Vx_" + zonename, ref_raster.spatialReference)
arcpy.DefineProjection_management(currentsimfolder + "\\Vy_" + zonename, ref_raster.spatialReference)
# Conversion des fichiers de sortie en raster pour ArcGIS
str_elev = currentsimfolder + "\\elev_" + zonename
arcpy.ASCIIToRaster_conversion(currentsimfolder + "\\" + zonename + "elev.txt", str_elev, "FLOAT")
# Ajout de la projection
arcpy.DefineProjection_management(str_elev, ref_raster.spatialReference)
if not arcpy.Exists(currentresult):
arcpy.Copy_management(currentsimfolder + "\\elev_" + "zone"+str(point[1]), currentresult)
else:
arcpy.Mosaic_management(currentsimfolder + "\\elev_" + "zone"+str(point[1]), currentresult, mosaic_type="MAXIMUM")
#arcpy.Copy_management(str_output + "\\lisflood_res", str_output + "\\tmp_mosaic")
#arcpy.Delete_management(str_output + "\\lisflood_res")
# arcpy.MosaicToNewRaster_management(';'.join([str_output + "\\tmp_mosaic", str_output + "\\elev_" + point[1]]),
# str_output,"lisflood_res",
# pixel_type="32_BIT_FLOAT",
# number_of_bands=1)
except BaseException as e:
filelog.write("ERREUR in " + simname + ": sim aborded during zone "+ str(point[1]) + "\n")
messages.addWarningMessage("Some simulations skipped. See log file.")
return
Feb 2, 2017 by nmtarr
Code to run analyses on the importance of southeastern woody wetlands
for wildlife
"""
import sys
sys.path.append('P:/Proj3/USGap/Scripts/SE_Woody_Wetlands')
execfile("T:/Scripts/AppendPaths27.py")
import arcpy
import pandas as pd
import SEWWConfig as floodconfig
pd.set_option('display.width', 1000)
arcpy.CheckOutExtension("Spatial")
arcpy.env.overwriteOutput = True
############################################# Mask the richness with the study region
######################################################################################
for group in floodconfig.richnessPathsCONUS:
print group
SE = arcpy.sa.ExtractByMask(
arcpy.Raster(floodconfig.richnessPathsCONUS[group]), floodconfig.AOI)
SE.save(floodconfig.richnessPathsSE[group])
############################################# Mask the richness with the study region
######################################################################################
for group in floodconfig.richnessPathsCONUS:
print group
MU = arcpy.sa.ExtractByMask(
arcpy.Raster(floodconfig.richnessPathsCONUS[group]),
arcpy.Raster(floodconfig.SEWW))
MU.save(floodconfig.richnessPathsFlood[group])
def long_task(self):
"""Background task that runs a long function with progress reports."""
import arcpy
import pandas as pd
import numpy as np
dataPath = "C:/Prog/banghendrik/Combinasi_654_Jabo_Lapan_modified.tif"
modelPath = "C:/Prog/banghendrik/DataTest_decisionTree.pkl"
outputPath = "C:/Prog/banghendrik/Combinasi_654_Jabo_Lapan_modified_clf.tif"
rasterarray = arcpy.RasterToNumPyArray(dataPath)
# proc = subprocess.Popen(
# ['dir'], #call something with a lot of output so we can see it
# shell=True,
# stdout=subprocess.PIPE
# )
# for line in iter(proc.stdout.readline,''):
# yield line.rstrip() + '<br/>\n'
data = np.array([rasterarray[0].ravel(), rasterarray[1].ravel(), rasterarray[2].ravel()])
data = data.transpose()
import pandas as pd
print("Change to dataframe format")
logging.info('Change to dataframe format')
columns = ['band1','band2', 'band3']
df = pd.DataFrame(data, columns=columns)
print("Split data to 20 chunks")
logging.info('Split data to 20 chunks')
df_arr = np.array_split(df, 20)
from sklearn.externals import joblib
clf = joblib.load(modelPath)
kelasAll = []
for i in range(len(df_arr)):
print ("predicting data chunk-"+str(i))
logging.info("predicting data chunk-"+str(i))
kelas = clf.predict(df_arr[i])
dat = pd.DataFrame()
dat['kel'] = kelas
print ("mapping to integer class")
logging.info("mapping to integer class")
mymap = {'awan':1, 'air':2, 'tanah':3, 'vegetasi':4}
dat['kel'] = dat['kel'].map(mymap)
band1Array = dat['kel'].values
print ("extend to list")
logging.info("extend to list")
kelasAll.extend(band1Array.tolist())
del df_arr
del clf
del kelas
del dat
del band1Array
del data
print ("change list to np array")
logging.info("change list to np array")
kelasAllArray = np.array(kelasAll, dtype=np.uint8)
print ("reshaping np array")
logging.info("reshaping np array")
band1 = np.reshape(kelasAllArray, (-1, rasterarray[0][0].size))
band1 = band1.astype(np.uint8)
raster = arcpy.Raster(dataPath)
inputRaster = dataPath
spatialref = arcpy.Describe(inputRaster).spatialReference
cellsize1 = raster.meanCellHeight
cellsize2 = raster.meanCellWidth
extent = arcpy.Describe(inputRaster).Extent
pnt = arcpy.Point(extent.XMin,extent.YMin)
del raster
# save the raster
print ("numpy array to raster ..")
logging.info("numpy array to raster ..")
out_ras = arcpy.NumPyArrayToRaster(band1, pnt, cellsize1, cellsize2)
#out_ras.save(outputPath)
#arcpy.CheckOutExtension("Spatial")
print ("define projection ..")
logging.info ("define projection ..")
arcpy.CopyRaster_management(out_ras, outputPath)
arcpy.DefineProjection_management(outputPath, spatialref)
verb = ['Starting up', 'Booting', 'Repairing', 'Loading', 'Checking']
adjective = ['master', 'radiant', 'silent', 'harmonic', 'fast']
noun = ['solar array', 'particle reshaper', 'cosmic ray', 'orbiter', 'bit']
message = ''
total = random.randint(10, 50)
for i in range(total):
if not message or random.random() < 0.25:
message = '{0} {1} {2}...'.format(random.choice(verb),
random.choice(adjective),
random.choice(noun))
self.update_state(state='PROGRESS',
meta={'current': i, 'total': total,
'status': message})
time.sleep(1)
return {'current': 100, 'total': 100, 'status': 'Task completed!',
'result': 42}
if desc.workspaceType == 'LocalDatabase': saveInGDB = True else: saveInGDB = False # Define the summary table (created later if necessary) if saveInGDB: summaryTableName = 'SLBL_results' else: summaryTableName = 'SLBL_results.dbf' summaryTable = os.path.join(ws,summaryTableName) arcpy.env.workspace = ws grid_dem_file = arcpy.Raster(grid_dem_file) #grid_dem_lyr = os.path.basename(grid_dem_file) #arcpy.MakeRasterLayer_management (grid_dem_file, grid_dem_lyr, "", "", "1") # Convert the polygon features to a raster mask try: arcpy.RecalculateFeatureClassExtent_management(mask_file) except: pass mask_desc = arcpy.Describe(mask_file) try: # Retrieve the selected polygons (works if the input is a layer) Set = mask_desc.FIDSet except: #makes a layer first if the input is a file if arcpy.GetInstallInfo()['ProductName'] == 'Desktop':
#https://community.esri.com/thread/139164
import arcpy
# reference your raster
ras = r"D:\Thesis\Data\Afg\ESA\ESACCI-LC-L4-LCCS-Map-300m-P5Y-2010-v1.6.1.tif"
raster = arcpy.Raster(ras)
# determine number of pixels
cnt_pix = raster.height * raster.width
# determine if raster has no data values
if int(arcpy.GetRasterProperties_management(ras,
"ANYNODATA").getOutput(0)) == 1:
# determine if raster has all data values
if int(
arcpy.GetRasterProperties_management(
ras, "ALLNODATA").getOutput(0)) == 1:
print "All cells of raster are NoData"
print "Data pixels : {0} ({1}%)".format(0, 0.0)
print "Nodata pixels: {0} ({1}%)".format(cnt_pix, 100.0)
else:
# handle integer different from float
if raster.isInteger and raster.hasRAT:
print "Integer raster with RAT"
lst_cnt = [r.COUNT for r in arcpy.SearchCursor(raster)]
cnt_data = sum(lst_cnt)
cnt_nodata = cnt_pix - cnt_data
else:
import sys
#from dbfpy import dbf #module for r/w dbf files with py available at http://dbfpy.sourceforge.net/
from arcpy import env
from random import randrange
jnk = randrange(10000)
arcpy.env.overwriteOutput = True
arcpy.env.workspace = wd
arcpy.env.compression = "LZW"
#arcpy.CreateFileGDB_management("D:/temp/arcgis/", "scratchoutput"+str(jnk)+".gdb")
#arcpy.env.scratchWorkspace = "D:/temp/arcgis/scratchoutput"+str(jnk)+".gdb"
if arcpy.CheckExtension("Spatial") == "Available":
arcpy.CheckOutExtension("Spatial")
roads_raster = arcpy.Raster(wd + "Roads_TigerLine_raster.tif")
habqual_raster = arcpy.Raster(wd + "habqual_v3_4.tif")
goodqual_raster = arcpy.sa.Con(habqual_raster, 1, 0, "Value=3")
notgoodqual_raster = arcpy.sa.Con(habqual_raster, 1, 0, "Value<3")
notgoodqual_raster = arcpy.sa.SetNull(notgoodqual_raster, 1, "Value=0")
roads_raster_buffer = arcpy.sa.EucDistance(roads_raster, 100, "", "")
roads_raster_buffer = arcpy.sa.Con(arcpy.sa.IsNull(roads_raster_buffer), 101,
roads_raster_buffer)
roads_raster_buffer = arcpy.sa.Int(
roads_raster_buffer
) #must convert to integerr to use conditional statement
roads_raster_buffer = arcpy.CalculateStatistics_management(roads_raster_buffer)
roads_raster_buffer_core = arcpy.sa.Con(roads_raster_buffer, 1, 0, "Value>100")
notgoodqual_raster_buffer = arcpy.sa.EucDistance(notgoodqual_raster, 100, "",
def getband_count(input_raster_path):
raster = arcpy.Raster(input_raster_path)
print(u"获取的波段数:" + str(raster.bandCount))
return raster.bandCount
#pFolderP = apwrutils.Utils.getcwd()
pFolderPRunName = os.path.join(pFolderP, runName)
pFolderPS = os.path.join(pFolderPRunName, "WKSP")
if (os.path.exists(pFolderPS) == False):
apwrutils.Utils.makeSureDirExists(pFolderPS)
ddt = time.clock()
arcpy.env.overwriteOutput = True
#..Create GDB with the runName, copy the inStream, inPoints etc to that GDB.
lDHs = sDH.split(";")
if (len(lDHs) > 0):
if (nProcessors == 0):
arcpy.AddMessage("It is required that nProcessors > 0")
pass
else:
inRaster = arcpy.Raster(inDemRaster)
arcpy.env.cellSize = inRaster.meanCellWidth
oDesc = arcpy.Describe(inCatchment)
sName = oDesc.name
oidFld = oDesc.oidFieldName
pWorkspace = apwrutils.Utils.getWorkspace(inCatchment)
pStatTable = os.path.join(pWorkspace, "{}_Stats".format(sName))
arcpy.Statistics_analysis(inCatchment, pStatTable,
[[oidFld, "MIN"], [oidFld, "MAX"]])
with arcpy.da.SearchCursor(
pStatTable,
["MIN_{}".format(oidFld), "MAX_{}".format(oidFld)
]) as rows:
for row in rows:
nMin = row[0]
nMax = row[1]
"""
License is Apache 2.0
"""
def rescale(raster, out_min=0, out_max=1):
arr_min, arr_max = raster.minimum, raster.maximum
m = (out_max - out_min) / (arr_max - arr_min)
b = out_min - m * arr_min
return m * raster + b
if __name__ == '__main__':
import arcpy
raster = arcpy.Raster(arcpy.Describe(arcpy.GetParameter(0)).catalogPath)
out_min = arcpy.GetParameter(1)
out_max = arcpy.GetParameter(2)
out_raster = arcpy.GetParameterAsText(3)
raster = rescale(raster, out_min, out_max)
raster.save(out_raster)
def main(best_plant_dir=str(),
lf_dir=str(),
crit_lf=float(),
prj_name=str(),
unit=str(),
version=str()):
""" derive and draw stabilizing features for vegetation plantings
crit_lf = 2.5 # years of minimum plant survival without stabilization
prj_name = "TBR" # corresponding to folder name
unit = "us" or "si"
version = "v10" # type() = 3-char str: vII
"""
logger = logging.getLogger("logfile")
logger.info("STABILIZING PLANTS ----- ----- ----- -----")
if unit == "us":
area_units = "SQUARE_FEET_US"
ft2_to_acres = config.ft2ac
else:
area_units = "SQUARE_METERS"
ft2_to_acres = 1.0
arcpy.CheckOutExtension('Spatial')
arcpy.gp.overwriteOutput = True
dir2pp = config.dir2pm + prj_name + "_" + version + "\\"
# folder settings
ras_dir = dir2pp + "Geodata\\Rasters\\"
shp_dir = dir2pp + "Geodata\\Shapefiles\\"
quant_dir = dir2pp + "Quantities\\"
# file and variable settings
xlsx_target = dir2pp + prj_name + "_assessment_" + version + ".xlsx"
feature_dict = {
"Large wood": 211,
"ELJs (plantings)": 212,
"Bioengineering (veget.)": 213,
"Bioengineering (mineral)": 214,
"Angular boulders (instream)": 215
}
# LOOK UP INPUT RASTERS
try:
logger.info("Looking up maximum lifespan rasters ...")
max_lf_plants = arcpy.Raster(ras_dir + "max_lf_pl_c.tif")
logger.info(" >> Vegetation plantings OK.")
logger.info(" -- OK (MaxLifespan raster read)\n")
except:
logger.info("ERROR: Could not find max. lifespan Rasters.")
return -1
logger.info("Looking up specific bioengineering lifespan rasters ...")
logger.info(best_plant_dir + "lf_wood.tif")
try:
lf_wood = arcpy.Raster(lf_dir + "lf_wood.tif")
logger.info(" >> Added Streamwood.")
except:
lf_wood = Float(0)
logger.info(
"WARNING: Could not find Lifespan Raster (%slf_wood.tif)." %
lf_dir)
logger.info(
" > Go to the Lifespan Tab and create lifespan rasters for the Bioengineering feature group."
)
logger.info(" > Applying 0-lifespans instead.")
try:
lf_bio = arcpy.Raster(lf_dir + "lf_bio_v_bio.tif")
logger.info(" >> Added Other bioengineering.")
except:
lf_bio = Float(0)
logger.info(
"WARNING: Could not find Lifespan Raster (%slf_bio_v_bio.tif)." %
lf_dir)
logger.info(
" > Go to the Lifespan Tab and create lifespan rasters for the Bioengineering feature group."
)
logger.info(" > Applying 0-lifespans instead.")
logger.info(" -- OK (Bioengineering raster read)")
# EVALUATE BEST STABILIZATION FEATURES
try:
logger.info("Assessing best features for plant stabilization.")
arcpy.env.extent = max_lf_plants.extent
best_stab = Con(
max_lf_plants <= crit_lf,
Con(
~IsNull(lf_wood),
Con(lf_wood > crit_lf, Int(feature_dict["Large wood"]),
Int(feature_dict["ELJs (plantings)"])),
Con(
~IsNull(lf_bio),
Con(lf_bio > crit_lf,
Int(feature_dict["Bioengineering (veget.)"]),
Int(feature_dict["Bioengineering (mineral)"])),
Int(feature_dict["Angular boulders (instream)"]))))
logger.info(" -- OK (Stabilization assessment.)\n")
except:
logger.info("ERROR: Best stabilization assessment failed.")
return -1
# SAVE RASTERS
try:
logger.info("Saving results raster as " + ras_dir + "plant_stab.tif")
best_stab.save(ras_dir + "plant_stab.tif")
logger.info(" -- OK (Raster saved.)\n")
except:
logger.info("ERROR: Result geofile saving failed.")
return -1
# SHAPEFILE CONVERSION AND STATS
try:
logger.info("Extracting quantities from geodata ...")
logger.info(" >> Converting results raster to polygon shapefile ...")
p_stab_shp = shp_dir + "Plant_stab.shp"
try:
arcpy.RasterToPolygon_conversion(Int(best_stab), p_stab_shp,
"NO_SIMPLIFY")
if not fGl.verify_shp_file(p_stab_shp):
logger.info(
"NO STABILIZATION MEASURE IDENTIFIED (EMPTY: %s)." %
p_stab_shp)
logger.info(fGl.open_file(xlsx_target))
return -1
except:
logger.info(
"NOTHING TO DO. Consider to increase the critical lifespan threshold."
)
logger.info(" >> Calculating area statistics ... ")
try:
arcpy.AddField_management(p_stab_shp, "F_AREA", "FLOAT", 9)
except:
logger.info(
" * field F_AREA already exists or the dataset is opened by another software."
)
try:
arcpy.CalculateGeometryAttributes_management(
p_stab_shp,
geometry_property=[["F_AREA", "AREA"]],
area_unit=area_units)
except:
logger.info(" * no plant stabilization applicable ")
logger.info(" >> Adding field (stabilizing feature) ... ")
try:
arcpy.AddField_management(p_stab_shp, "Stab_feat", "TEXT")
except:
logger.info(" * field Stab_feat already exists ")
logger.info(" >> Evaluating field (stabilizing feature) ... ")
inv_feature_dict = {v: k for k, v in feature_dict.items()}
code_block = "inv_feature_dict = " + str(inv_feature_dict)
try:
arcpy.CalculateField_management(p_stab_shp, "Stab_feat",
"inv_feature_dict[!gridcode!]",
"PYTHON", code_block)
except:
logger.info(" * no plant stabilization added ... ")
logger.info(" >> Exporting tables ...")
arcpy.TableToTable_conversion(p_stab_shp, quant_dir, "plant_stab.txt")
logger.info(" -- OK (Quantity export)\n")
except:
logger.info("ERROR: Shapefile operations failed.")
return -1
# PREPARE AREA DATA (QUANTITIES)
logger.info("Processing table statistics ...")
write_dict = {}
for k in feature_dict.keys():
write_dict.update({k: 0.0}) # set to zero for surface count
stat_data = fGl.read_txt(quant_dir + "plant_stab.txt")
logger.info(" >> Extracting relevant area sizes ...")
for row in stat_data:
try:
write_dict[inv_feature_dict[int(row[0])]] += row[1]
except:
logger.info(" --- Unknown key: " + str(int(row[0])))
if unit == "us":
logger.info(" >> Converting ft2 to acres ...")
for k in write_dict.keys():
write_dict[k] = write_dict[k] * float(ft2_to_acres)
logger.info(" -- OK (Area extraction finished)\n")
# WRITE AREA DATA TO EXCEL FILE
logger.info("Writing results to costs workbook (sheet: from_geodata) ...")
fGl.write_dict2xlsx(write_dict, xlsx_target, "B", "C", 12)
# CLEAN UP useless shapefiles
logger.info("Cleaning up redundant shapefiles ...")
arcpy.env.workspace = shp_dir
all_shps = arcpy.ListFeatureClasses()
for shp in all_shps:
if "_del" in str(shp):
try:
arcpy.Delete_management(shp)
except:
logger.info(
str(shp) +
" is locked. Remove manually to avoid confusion.")
arcpy.env.workspace = dir2pp + "Geodata\\"
logger.info(" -- OK (Clean up)\n")
#prepares the sample data for the development of the models
import arcpy
import numpy
myworkspace = "D:/CCW20/GIS"
cmapsdir = myworkspace + "/climatemaps"
dhmraster = arcpy.Raster("D:/CCW20/GIS/dhm25.tif")
arcpy.env.overwriteOutput = True
arcpy.CheckOutExtension('Spatial')
#read the positive sample dataset
samples_n_fc = myworkspace + "/samples.gdb/samples_n_6190"
samples_s_fc = myworkspace + "/samples.gdb/samples_s_6190"
arcpy.env.workspace = cmapsdir
inrasterlist = [["dhm25.tif", "dhm25"], ["litho7g.tif", "litho7g"],
["tyymin6190.tif", "tyymin6190"],
["tyymean6190.tif", "tyymean6190"],
["tyymax6190.tif", "tyymax6190"],
["toctmin6190.tif", "toctmin6190"],
["toctmean6190.tif", "toctmean6190"],
["toctmax6190.tif", "toctmax6190"],
["tjulmin6190.tif", "tjulmin6190"],
["tjulmean6190.tif", "tjulmean6190"],
["tjulmax6190.tif", "tjulmax6190"],
["tjanmin6190.tif", "tjanmin6190"],
["tjanmean6190.tif", "tjanmean6190"],
["tjanmax6190.tif", "tjanmax6190"],
["taprmin6190.tif", "taprmin6190"],
["taprmean6190.tif", "taprmean6190"],
["taprmax6190.tif", "taprmax6190"], ["tabsmin.tif", "tabsmin"],
["tabsmax.tif", "tabsmax"], ["rnormyy6190.tif", "rnormyy6190"],
def RevalueRaster(f_path, elev_type, raster_props, target_path, publish_path, minZ, maxZ, bound_path, spatial_ref=None):
arcpy.AddMessage("RevalueRaster {} {}: ZRange({},{})".format(elev_type, f_path,minZ,maxZ))
Utility.setArcpyEnv(is_overwrite_output=True)
a = datetime.now()
nodata = RasterConfig.NODATA_DEFAULT
isInt = (elev_type == INT)
if isInt:
minZ, maxZ = 0, 255
arcpy.AddMessage("RevalueRaster type {} is intensity {}: ZRange({},{})".format(elev_type, f_path,minZ,maxZ))
f_name, target_f_path, publish_f_path, stat_out_folder, stat_file_path, bound_out_folder, vector_bound_path = getFilePaths(f_path, elev_type, target_path, publish_path) # @UnusedVariable
# target_f_left, target_f_right = os.path.splitext(target_f_path)
# target1_f_path = "{}1{}".format(target_f_left, target_f_right)
publish_f_left, publish_f_right = os.path.splitext(publish_f_path)
publish1_f_path = "{}1{}".format(publish_f_left, publish_f_right)
# Don't maintain fGDB raster format, update to TIFF
# if raster_props[FORMAT] == "FGDBR":
# target_f_path = "{}.TIF".format(target_f_path)
if raster_props[BAND_COUNT] <> 1:
arcpy.AddMessage("Skipping Raster {}, not 1 band image.".format(f_path))
else:
# Intensity may be another type
if not isInt and not (raster_props[PIXEL_TYPE] == PIXEL_TYPE_F32 or raster_props[PIXEL_TYPE] == PIXEL_TYPE_D64):
arcpy.AddMessage("Skipping Raster '{}', '{}' not Float32 type image.".format(f_path, raster_props[PIXEL_TYPE]))
else:
if not (raster_props[FORMAT] == "TIFF" or raster_props[FORMAT] == "GRID" or raster_props[FORMAT] == "IMAGINE Image" or raster_props[FORMAT] == "FGDBR"):
arcpy.AddMessage("Skipping Raster '{}', '{}' not supported image format.".format(f_path, raster_props[FORMAT]))
else:
if arcpy.Exists(target_f_path):
arcpy.AddMessage("\tDerived Raster exists: {}".format(target_f_path))
else:
deleteFileIfExists(target_f_path, True)
arcpy.AddMessage("\tSaving derived raster to {}".format(target_f_path))
# Compression isn't being applied properly so results are uncompressed
rasterObject = arcpy.Raster(f_path)
if isInt:
mean = rasterObject.mean
stdDev = rasterObject.standardDeviation
maximumPixel = mean + (stdDev * 2)
linearTransform = arcpy.sa.TfLinear(maximum=maximumPixel, upperThreshold=maximumPixel)
outRescale = arcpy.sa.RescaleByFunction(rasterObject, linearTransform, minZ, maxZ)
outRescale.save(target_f_path)
del outRescale, rasterObject
else:
outSetNull = arcpy.sa.Con(((rasterObject >= (float(minZ))) & (rasterObject <= (float(maxZ)))), f_path) # @UndefinedVariable
outSetNull.save(target_f_path)
del outSetNull, rasterObject
if spatial_ref is not None:
arcpy.AddMessage("Applying projection to raster '{}' {}".format(target_f_path, spatial_ref))
if str(spatial_ref).lower().endswith(".prj"):
arcpy.AddMessage("loading spatial reference from prj file '{}'".format(spatial_ref))
spatial_ref = arcpy.SpatialReference(spatial_ref)
arcpy.AddMessage("loaded spatial reference from prj file '{}'".format(spatial_ref))
# 3/22/18 - Handle UTF-8 Encoding - 'u\u2013' From MI Delta
try:
arcpy.AddMessage("Applying projection '{}'".format( spatial_ref))
arcpy.AddMessage("Applying string projection '{}'".format( spatial_ref.exportToString()))
arcpy.AddMessage("Applying encoded projection '{}'".format( spatial_ref.exportToString().encode('utf-8')))
except Exception as e:
arcpy.AddMessage('Error: {}'.format(e))
arcpy.DefineProjection_management(in_dataset=target_f_path, coor_system=spatial_ref)
# Set the no data default value on the input raster
arcpy.SetRasterProperties_management(in_raster=target_f_path, data_type="ELEVATION", nodata="1 {}".format(nodata))
arcpy.CalculateStatistics_management(in_raster_dataset=target_f_path, x_skip_factor="1", y_skip_factor="1", ignore_values="", skip_existing="OVERWRITE", area_of_interest="Feature Set")
# arcpy.BuildPyramidsandStatistics_management(in_workspace=target_f_path,
# build_pyramids="BUILD_PYRAMIDS",
# calculate_statistics="CALCULATE_STATISTICS",
# BUILD_ON_SOURCE="BUILD_ON_SOURCE",
# pyramid_level="-1",
# SKIP_FIRST="NONE",
# resample_technique="BILINEAR",
# compression_type="LZ77",
# compression_quality="75",
# skip_existing="SKIP_EXISTING")
# make sure we make a new published copy of this
if arcpy.Exists(publish_f_path):
arcpy.Delete_management(publish_f_path)
a = doTime(a, "\tCopied '{}' to '{}' with valid values between {} and {}".format(f_path, target_f_path, minZ, maxZ))
if arcpy.Exists(publish_f_path):
arcpy.AddMessage("\tPublish Raster exists: {}".format(publish_f_path))
else:
arcpy.AddMessage("\tCopy and clip published raster from {} to {}".format(target_f_path, publish1_f_path))
a = datetime.now()
deleteFileIfExists(publish1_f_path, True)
deleteFileIfExists(publish_f_path, True)
# arcpy.RasterToOtherFormat_conversion(target_f_path, publish_f_path, Raster_Format="TIFF")
arcpy.CopyRaster_management(in_raster=target_f_path, out_rasterdataset=publish1_f_path, config_keyword="", background_value="", nodata_value=nodata, onebit_to_eightbit="NONE", colormap_to_RGB="NONE", pixel_type="32_BIT_FLOAT", scale_pixel_value="NONE", RGB_to_Colormap="NONE", format="TIFF", transform="NONE")
arcpy.AddMessage("\tCliping temp raster {} to {}".format(publish1_f_path, publish_f_path))
arcpy.Clip_management(in_raster=publish1_f_path, out_raster=publish_f_path, in_template_dataset=bound_path, nodata_value=nodata, clipping_geometry="ClippingGeometry", maintain_clipping_extent="NO_MAINTAIN_EXTENT")
deleteFileIfExists(publish1_f_path, True)
arcpy.SetRasterProperties_management(in_raster=publish_f_path, data_type="ELEVATION", nodata="1 {}".format(nodata))
arcpy.CalculateStatistics_management(in_raster_dataset=publish_f_path, x_skip_factor="1", y_skip_factor="1", ignore_values="", skip_existing="OVERWRITE", area_of_interest="Feature Set")
# arcpy.BuildPyramidsandStatistics_management(in_workspace=publish_f_path,
# build_pyramids="BUILD_PYRAMIDS",
# calculate_statistics="CALCULATE_STATISTICS",
# BUILD_ON_SOURCE="BUILD_ON_SOURCE",
# pyramid_level="-1",
# SKIP_FIRST="NONE",
# resample_technique="BILINEAR",
# compression_type="LZ77",
# compression_quality="75",
# skip_existing="SKIP_EXISTING")
a = doTime(a, "\tCopied '{}' to '{}'".format(target_f_path, publish_f_path))
def main():
print "load modules..."
import arcpy
arcpy.env.overwriteOutput = True
import numpy as np
template1 = r'C:\GeoNet\Correlation\Parameter1\r{0}_NPP.TIF'
template2 = r'C:\GeoNet\Correlation\Parameter2\r{0}_WUE.TIF'
nodata = -3.4028235e+38
out_ras = r'C:\GeoNet\Correlation\correlation.TIF'
print "create nested numpy array list..."
lst_np_ras = []
for i in range(1, 14):
ras_path1 = template1.format("%03d" % (i, ))
print " - ", ras_path1
ras_np1 = arcpy.RasterToNumPyArray(ras_path1)
ras_path2 = template2.format("%03d" % (i, ))
print " - ", ras_path2
ras_np2 = arcpy.RasterToNumPyArray(ras_path2)
lst_np_ras.append([ras_np1, ras_np2])
print "read props numpy raster..."
ras_np = lst_np_ras[0][0] # take first numpy array from list
rows = ras_np.shape[0]
cols = ras_np.shape[1]
print " - rows:", rows
print " - cols:", cols
print "create output numpy array..."
ras_path = template1.format("%03d" % (1, ))
raster = arcpy.Raster(ras_path)
ras_np_res = np.ndarray((rows, cols))
print " - out rows:", ras_np_res.shape[0]
print " - out cols:", ras_np_res.shape[1]
print "loop through pixels..."
pix_cnt = 0
for row in range(rows):
for col in range(cols):
pix_cnt += 1
if pix_cnt % 5000 == 0:
print " - row:", row, " col:", col, " pixel:", pix_cnt
lst_vals1 = []
lst_vals2 = []
try:
for lst_pars in lst_np_ras:
lst_vals1.append(lst_pars[0][row, col])
lst_vals2.append(lst_pars[1][row, col])
lst_vals1 = ReplaceNoData(lst_vals1, nodata)
lst_vals2 = ReplaceNoData(lst_vals2, nodata)
# perform calculation on list
correlation = CalculateCorrelation(lst_vals1, lst_vals2,
nodata)
ras_np_res[row, col] = correlation
except Exception as e:
print "ERR:", e
print " - row:", row, " col:", col, " pixel:", pix_cnt
print " - lst_vals1:", lst_vals1
print " - lst_vals2:", lst_vals2
pnt = arcpy.Point(raster.extent.XMin,
raster.extent.YMin) # - raster.meanCellHeight
xcellsize = raster.meanCellWidth
ycellsize = raster.meanCellHeight
print "Write output raster..."
print " - ", out_ras
ras_res = arcpy.NumPyArrayToRaster(ras_np_res,
lower_left_corner=pnt,
x_cell_size=xcellsize,
y_cell_size=ycellsize,
value_to_nodata=nodata)
ras_res.save(out_ras)
arcpy.DefineProjection_management(
in_dataset=out_ras,
coor_system=
"GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]"
)
(0.2 * in_band_nir - in_band_red)) / (0.2 * in_band_nir + in_band_red)
return WDRVI_result
# Check
def WVVI(in_band_nir, in_band_red, out_WVVI=None):
WVVI_result = ((in_band_nir * 2 - in_band_red) /
(in_band_nir * 2 + in_band_red))
return WVVI_result
if __name__ == "__main__":
arcpy.env.overwriteOutput = True
band_nir = arcpy.Raster(
r"D:\Python\Test\Baza\ImaginiT\LC08_L1TP_183029_20190821_20190903_01_T1\LC08_L1TP_183029_20190821_20190903_01_T1_B5.TIF"
)
band_red = arcpy.Raster(
r"D:\Python\Test\Baza\ImaginiT\LC08_L1TP_183029_20190821_20190903_01_T1\LC08_L1TP_183029_20190821_20190903_01_T1_B4.TIF"
)
band_blue = arcpy.Raster(
r"D:\Python\Test\Baza\ImaginiT\LC08_L1TP_183029_20190821_20190903_01_T1\LC08_L1TP_183029_20190821_20190903_01_T1_B2.TIF"
)
band_green = arcpy.Raster(
r"D:\Python\Test\Baza\ImaginiT\LC08_L1TP_183029_20190821_20190903_01_T1\LC08_L1TP_183029_20190821_20190903_01_T1_B3.TIF"
)
output = r"D:\Python\Test\Baza\ImaginiT\Rezultate_functii"
# mediana lungimii de unda
# Trebuie sa rezulte 29 de Indici
# EVI,GARI,LAI,MNLI,NLI ies fara valori
def zonalStatistics(in_shp_path, in_dem):
in_shp_dir = os.path.split(in_shp_path)[0]
in_shp_name = os.path.split(in_shp_path)[1]
arcpy.env.workspace = in_shp_dir
arcpy.env.overwriteOutput = True
arcpy.env.snapRaster = in_dem
dbf_dir = os.path.join(in_shp_dir, "dbf")
os.mkdir(dbf_dir)
tif_dir = os.path.join(in_shp_dir, "tif")
os.mkdir(tif_dir)
shapefiles = os.listdir(in_shp_dir)
dem = arcpy.Raster(in_dem)
cell_size = dem.meanCellHeight
for shp in shapefiles:
if shp.endswith(".shp") and shp == in_shp_name:
shp_path = os.path.join(in_shp_dir, shp)
dbf_path = os.path.join(dbf_dir,
"zonal_" + shp.replace("shp", "dbf"))
tif_path = os.path.join(tif_dir, shp.replace("shp", "tif"))
arcpy.PolygonToRaster_conversion(
shp_path,
value_field="FID",
out_rasterdataset=tif_path,
cell_assignment="CELL_CENTER",
priority_field="NONE",
cellsize=cell_size,
)
arcpy.sa.ZonalStatisticsAsTable(tif_path, "Value", in_dem,
dbf_path, "DATA", "ALL")
arcpy.JoinField_management(
shp_path,
in_field="FID",
join_table=dbf_path,
join_field="Value",
fields="COUNT;MIN;MAX;RANGE;MEAN;STD;SUM",
)
# arcpy.AddField_management(shp_path,field_name="dep2catR",field_type="FLOAT")
arcpy.AddField_management(shp_path,
field_name="volume",
field_type="FLOAT")
arcpy.AddField_management(shp_path,
field_name="mean_depth",
field_type="FLOAT")
# arcpy.CalculateField_management(shp_path,field="dep2catR",expression="!AREA! / !cat_area!", expression_type="PYTHON_9.3")
arcpy.CalculateField_management(
shp_path,
field="volume",
expression="( !COUNT! * !MAX! - !SUM!) * ( !AREA! / !COUNT! )",
expression_type="PYTHON_9.3",
)
arcpy.CalculateField_management(
shp_path,
field="mean_depth",
expression="!volume! / !AREA!",
expression_type="PYTHON_9.3",
)
arcpy.CalculateField_management(
shp_path,
field="ID",
expression="!FID! + 1",
expression_type="PYTHON_9.3",
)
arcpy.DeleteField_management(shp_path, drop_field="GRIDCODE")
if os.path.exists(dbf_dir):
shutil.rmtree(dbf_dir)
if os.path.exists(tif_dir):
shutil.rmtree(tif_dir)
return True
def main():
"""
Calculate water depth from a flood extent polygon (e.g. from remote sensing analysis) based on
an underlying DEM (or HAND).
Program procedure:
1. Flood extent polygon to polyline
2. Polyline to Raster - DEM extent and resolution (Env)
3. Con - DEM values to Raster
4. Euclidean Allocation - assign boundary cell elevation to nearest domain cells
5. Calculate water depth by deducting DEM by Euclidean Allocation
6. Run low-pass Filter
Created by Sagy Cohen and Austin Raney, Surface Dynamics Modeling Lab, University of Alabama
email: [email protected]; [email protected]
web: http://sdml.ua.edu
"""
####################
# INPUT/OUTPUT #
####################
# Set the Workspace and Scratch space to the first param provided
ws = arcpy.env.workspace = script.GetParameterAsText(0)
arcpy.env.scratchWorkspace = script.GetParameterAsText(0)
# Set Input DEM, Inundation Polygon.
dem_name = os.path.basename(script.GetParameterAsText(2))
# Create raster object from DEM
dem = arcpy.Raster(dem_name)
inund_polygon = os.path.basename(script.GetParameterAsText(1))
# If this is not provided, the clip_dem will be calculated with the Clip_management function
clip_dem = script.GetParameterAsText(4)
# Check if optional Cost Raster was provided
if script.GetParameterAsText(5):
cost_raster = script.GetParameterAsText(5)
else:
cost_raster = (((dem <= 0)*999)+1)
cost_raster.save(ws + '\cost_raster')
####################
# END INPUT/OUTPUT #
####################
# Set overriding within the Workspace to True
arcpy.env.overwriteOutput = True
# Cell size here would be the x or y distance resolution from the raster
# i.e., a 30 meter dem would have a cell size of 30
cell_size = dem.meanCellHeight
# Generate raster line. See CalculateBoundary docstring for more info
boundary = CalculateBoundary(dem, inund_polygon, cell_size, ws)
# Proper string representation of dem extent to be accepted by Clip_management method
extent = '{} {} {} {}'.format(dem.extent.XMin, dem.extent.YMin, dem.extent.XMax, dem.extent.YMax)
# If optional clip dem no provided then create a clipping dem cut out from the flood inundation polygon
if not clip_dem:
clip_dem = 'Clip_DEM'
arcpy.Clip_management(dem_name, extent, clip_dem, inund_polygon,
cell_size, 'ClippingGeometry', 'NO_MAINTAIN_EXTENT')
arcpy.env.extent = arcpy.Extent(dem.extent.XMin, dem.extent.YMin, dem.extent.XMax, dem.extent.YMax)
print('Convert boundary to integer')
# Must convert boundary, i.e., raster line to int for cost allocation function. It only takes int rasters
MULTIPLIER = 10000
boundary_int = Int(boundary * MULTIPLIER)
boundary_int.save('boundary_int')
print('Running cost allocation')
cost_alloc = CostAllocation(boundary_int, cost_raster, '#', '#', 'Value')
cost_alloc.save('CostAlloc_int')
# Divide the result from the cost allocation function using the same constant used to create the integer
# representation of the boundary
cost_alloc = Float(cost_alloc) / MULTIPLIER
cost_alloc.save('cost_alloc')
print('Calculating estimated water depth')
# Raster calculator cost_alloc - clip_dem
water_depth = Minus(cost_alloc, clip_dem)
# Remove estimated water depths below 0 and change them to 0
water_depth = Con(water_depth <= 0, 0, water_depth)
water_depth.save(os.path.basename(script.GetParameterAsText(3)))
print('Calculating low pass filter')
water_depth_filtered = Filter(water_depth, 'LOW', 'DATA')
waterDepthFilter2 = Con(clip_dem, water_depth_filtered, '#', 'VALUE > 0')
waterDepthFilter2.save(os.path.basename(script.GetParameterAsText(3))+'_filtered')
print('Done')
Args:
inRas (raster) -- Input filled digital elevation model.
Flow_Direction (raster) -- Output flow direction grid.
Returns:
FlowDirGrid (raster) -- Flow direction grid.
"""
import csv
import random
import matplotlib
import arcpy
import numpy
# Get user to select input raster surface.
inRas = arcpy.Raster(arcpy.GetParameterAsText(0))
# Find lower left coordinate of input raster.
lowerLeft = arcpy.Point(inRas.extent.XMin, inRas.extent.YMin)
# Find cell size of input raster.
cellSize = inRas.meanCellWidth
# Convert raster to numpy array.
land = arcpy.RasterToNumPyArray(inRas)
# Get user to name output flow direction raster.
Flow_Direction = arcpy.GetParameterAsText(1)
w = len(land) - 2 # Set width to len(land) - 2.
h = len(land) - 2 # Set height to len(land) - 2.
print "Loading arcpy"
# import library packages
import arcpy, os, sys, numpy
from bmpFlowModFast import *
print "Checking inputs"
# get parameters (input and output datasets, filenames, etc)
# Flow_Direction = Raster(arcpy.getParameterAsText(0))
# BMP_Points = Raster(arcpy.getParameterAsText(1))
# Output = arcpy.getParameterAsText(2)
Flow_Direction = arcpy.Raster(
"C:/Users/csomerlot/Desktop/Lab05Data/Lab05Geodatabase.gdb/FlowDir_Fill1")
BMP_Points = arcpy.Raster(
"C:/Users/csomerlot/Desktop/Lab05Data/Lab05Geodatabase.gdb/BMP_Points_PointToRaster"
)
Output = "C:/Users/csomerlot/Desktop/Lab05Data/Lab05Geodatabase.gdb/output"
# set environment
# create variables to hold input and output datasets
flowdirData = arcpy.RasterToNumPyArray(Flow_Direction)
lowerLeft = arcpy.Point(Flow_Direction.extent.XMin, Flow_Direction.extent.YMin)
cellSize = Flow_Direction.meanCellWidth
height = len(flowdirData)
width = len(flowdirData[0])
bmppointData = arcpy.RasterToNumPyArray(BMP_Points)
if BMP_Points.extent.XMin != Flow_Direction.extent.XMin:
print BMP_Points.extent.XMin, Flow_Direction.extent.XMin
raise Exception("Xmin of extents not the same")
if BMP_Points.extent.YMin != Flow_Direction.extent.YMin:
# CROP: a raster mask is provided in this repo. It is a GRID file named mask_data
# MODIS DATA: https://lpdaac.usgs.gov/dataset_discovery/modis/modis_products_table/mod11a2
import arcpy
import os
# Check out any necessary licenses
arcpy.CheckOutExtension("spatial")
# 'parent_dir' is the pathway for the folder containing raw HDF_EOS (MOD11A2 product) files
parent_dir = "your_pathway\\to_the\\folder\\with\\modis\\data " # Note the "\\".
#'path2mask' is is the pathway for the mask data (shapefile or raster)
# I provided a mask for Kaparao National Park in MODIS_CLIMATOLOGIES repo.
path2mask = "your_path_to_mask\\mask_data" # Note the "\\"
mask_data = arcpy.Raster(path2mask)
arcpy.env.workspace = parent_dir
os.chdir(parent_dir)
os.mkdir(hdf2raster)
os.mkdir(parent_dir + '\\pro_data')
os.mkdir(parent_dir + '\\final')
hdf2raster = parent_dir + '\\hdf2raster'
prodata = parent_dir + "\\pro_data"
final = parent_dir + '\\final'
lista = arcpy.ListDatasets()
hdf_files = [x for x in lista if '.hdf' in x]
fn_vars = ['a14', 'da', 'ni']
if IN_JY == "99999":
VAR_1 = "0"
IN_JY = create_raster(5, IN_CLIP, VAR_FBL, "tihuan.tif")
if IN_GW == "99999":
VAR_2 = "0"
IN_GW = create_raster(5, IN_CLIP, VAR_FBL, "tihuan1.tif")
if IN_DW == "99999":
VAR_3 = "0"
IN_DW = create_raster(5, IN_CLIP, VAR_FBL, "tihuan2.tif")
if IN_DF == "99999":
VAR_4 = "0"
IN_DF = create_raster(5, IN_CLIP, VAR_FBL, "tihuan3.tif")
if IN_GH == "99999":
VAR_5 = "0"
IN_GH = create_raster(5, IN_CLIP, VAR_FBL, "tihuan4.tif")
f = float(VAR_1) * arcpy.Raster(IN_JY) + float(VAR_2) * arcpy.Raster(
IN_GW) + float(VAR_3) * arcpy.Raster(IN_DW) + float(VAR_4) * arcpy.Raster(
IN_DF) + float(VAR_5) * arcpy.Raster(IN_GH)
f.save("ff.tif")
#################################
outReclass2 = arcpy.sa.Reclassify(
"ff.tif", "Value",
arcpy.sa.RemapRange([[float(VAR_ZH1), float(VAR_ZH2), 1],
[float(VAR_ZH2), float(VAR_ZH3), 2],
[float(VAR_ZH3), float(VAR_ZH4), 3],
[float(VAR_ZH4), float(VAR_ZH5), 4],
[float(VAR_ZH5), float(VAR_ZH6), 5]]), 'NODATA')
outReclass2.save(OUTPUTPATH + OUTPUTNAME + ".tif")
arcpy.BuildRasterAttributeTable_management(OUTPUTPATH + OUTPUTNAME + ".tif",
"Overwrite")
#-------------------------------------------------------------------------------
# DESCRIBE RASTER
#-------------------------------------------------------------------------------
import arcpy
# Set the current workspace
arcpy.env.workspace = "C:\Users\laboratorios\ELVLC\DATA\sagunto"
desc = arcpy.Describe(arcpy.env.workspace)
# Get and print a list of GRIDs from the workspace
rasters = arcpy.ListRasters("*", "ALL")
for raster in rasters:
i = arcpy.Raster(raster)
print(raster)
print "Name: ", i.name
if hasattr(desc, "name"):
print "Name: " + desc.name
if hasattr(desc, "dataType"):
print "DataType: " + desc.dataType
if hasattr(desc, "catalogPath"):
print "CatalogPath: " + desc.catalogPath
#-------------------------------------------------------------------------------
# Extract features to a new feature class based on a Location and an attribute query
#-------------------------------------------------------------------------------
# Import arcpy and set path to data
import arcpy
arcpy.env.workspace = r"C:\Users\laboratorios\ELVLC\DATA\castilla-leon"
def create_input_nc(start_date,
years,
cellsize,
basin_shp,
p_path,
et_path,
eto_path,
lai_path,
swi_path,
swio_path,
swix_path,
qratio_path,
rainydays_path,
thetasat_ras,
rootdepth_ras,
input_nc,
epsg=4326,
bbox=None):
"""
Creates the input netcdf file required to run waterpix
"""
# Script parameters
print "Variable\tRaster"
arcpy.CheckOutExtension('spatial')
if bbox:
latlim = [bbox[1], bbox[3]]
lonlim = [bbox[0], bbox[2]]
else:
shp_extent = arcpy.Describe(basin_shp).extent
latlim = [shp_extent.YMin, shp_extent.YMax]
lonlim = [shp_extent.XMin, shp_extent.XMax]
arcpy.env.extent = arcpy.Extent(lonlim[0], latlim[0], lonlim[1], latlim[1])
arcpy.env.cellSize = cellsize
time_range = pd.date_range(start_date, periods=12 * years, freq='MS')
time_ls = [d.strftime('%Y%m') for d in time_range]
time_dt = [pd.to_datetime(i, format='%Y%m') for i in time_ls]
time_n = len(time_ls)
years_ls = set()
years_ls = [
i.year for i in time_dt
if i.year not in years_ls and not years_ls.add(i.year)
]
time_indeces = {}
for j, item in enumerate(years_ls):
temp_ls = [
int(i.strftime('%Y%m')) for i in pd.date_range(
str(item) + '0101', str(item) + '1231', freq='MS')
]
time_indeces[item] = [time_ls.index(str(i)) for i in temp_ls]
for key in time_indeces.keys():
if time_indeces[key] != range(time_indeces[key][0],
time_indeces[key][-1] + 1):
raise Exception('The year {0} in the netcdf file is incomplete'
' or the dates are non-consecutive')
all_paths = {
'p': p_path,
'et': et_path,
'eto': eto_path,
'lai': lai_path,
'swi': swi_path,
'swio': swio_path,
'swix': swix_path,
'qratio': qratio_path,
'rainydays': rainydays_path
}
# Latitude and longitude
lat_ls = pd.np.arange(latlim[0] + 0.5 * cellsize,
latlim[1] + 0.5 * cellsize, cellsize)
lat_ls = lat_ls[::-1] # ArcGIS numpy
lon_ls = pd.np.arange(lonlim[0] + 0.5 * cellsize,
lonlim[1] + 0.5 * cellsize, cellsize)
lat_n = len(lat_ls)
lon_n = len(lon_ls)
spa_ref = arcpy.SpatialReference(epsg)
projection = spa_ref.exportToString()
ll_corner = arcpy.Point(lonlim[0], latlim[0])
# Snap raster
temp_ras = arcpy.NumPyArrayToRaster(pd.np.zeros((lat_n, lon_n)), ll_corner,
cellsize, cellsize)
scratch_ras = arcpy.CreateScratchName('ras_', '.tif', '',
arcpy.env.scratchFolder)
temp_ras.save(scratch_ras)
arcpy.management.DefineProjection(scratch_ras, spa_ref)
arcpy.env.snapRaster = scratch_ras
# Basin mask
basin_ras = arcpy.CreateScratchName('bas_', '.tif', '',
arcpy.env.scratchFolder)
buff_shp = arcpy.CreateScratchName('bas_', '.shp', '',
arcpy.env.scratchFolder)
arcpy.analysis.Buffer(basin_shp, buff_shp, 2 * cellsize, 'FULL', 'ROUND',
'NONE', '#', 'PLANAR')
arcpy.conversion.FeatureToRaster(buff_shp, "FID", basin_ras, cellsize)
# Create NetCDF file
nc_file = netCDF4.Dataset(input_nc, 'w', format="NETCDF4")
nc_file.set_fill_on()
# Create dimensions
lat_dim = nc_file.createDimension('latitude', lat_n)
lon_dim = nc_file.createDimension('longitude', lon_n)
month_dim = nc_file.createDimension('time_yyyymm', time_n)
year_dim = nc_file.createDimension('time_yyyy', len(years_ls))
# Create NetCDF variables
crs_var = nc_file.createVariable('crs', 'i', (), fill_value=-9999)
crs_var.standard_name = 'crs'
crs_var.grid_mapping_name = 'latitude_longitude'
crs_var.crs_wkt = projection
lat_var = nc_file.createVariable('latitude',
'f8', ('latitude'),
fill_value=-9999)
lat_var.units = 'degrees_north'
lat_var.standard_name = 'latitude'
lon_var = nc_file.createVariable('longitude',
'f8', ('longitude'),
fill_value=-9999)
lon_var.units = 'degrees_east'
lon_var.standard_name = 'longitude'
month_var = nc_file.createVariable('time_yyyymm',
'l', ('time_yyyymm'),
fill_value=-9999)
month_var.standard_name = 'time'
month_var.format = 'YYYYMM'
year_var = nc_file.createVariable('time_yyyy',
'l', ('time_yyyy'),
fill_value=-9999)
year_var.standard_name = 'time'
year_var.format = 'YYYY'
# Variables
p_var = nc_file.createVariable('Precipitation_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
p_var.long_name = 'Precipitation'
p_var.units = 'mm/month'
py_var = nc_file.createVariable('Precipitation_Y',
'f8',
('time_yyyy', 'latitude', 'longitude'),
fill_value=-9999)
py_var.long_name = 'Precipitation'
py_var.units = 'mm/year'
et_var = nc_file.createVariable('Evapotranspiration_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
et_var.long_name = 'Evapotranspiration'
et_var.units = 'mm/month'
ety_var = nc_file.createVariable('Evapotranspiration_Y',
'f8',
('time_yyyy', 'latitude', 'longitude'),
fill_value=-9999)
ety_var.long_name = 'Evapotranspiration'
ety_var.units = 'mm/year'
eto_var = nc_file.createVariable('ReferenceET_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
eto_var.long_name = 'Reference Evapotranspiration'
eto_var.units = 'mm/month'
lai_var = nc_file.createVariable('LeafAreaIndex_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
lai_var.long_name = 'Leaf Area Index'
lai_var.units = 'm2/m2'
swi_var = nc_file.createVariable('SWI_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
swi_var.long_name = 'Soil Water Index - Monthly mean'
swi_var.units = '%'
swio_var = nc_file.createVariable('SWIo_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
swio_var.long_name = 'Soil water index - First day of the month'
swio_var.units = '%'
swix_var = nc_file.createVariable('SWIx_M',
'f8',
('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
swix_var.long_name = 'Soil water index - Last day of the month'
swix_var.units = '%'
qratio_var = nc_file.createVariable('RunoffRatio_Y',
'f8',
('time_yyyy', 'latitude', 'longitude'),
fill_value=-9999)
qratio_var.long_name = 'Runoff ratio'
qratio_var.units = '-'
rainydays_var = nc_file.createVariable(
'RainyDays_M',
'f8', ('time_yyyymm', 'latitude', 'longitude'),
fill_value=-9999)
rainydays_var.long_name = 'Number of rainy days per month'
rainydays_var.units = 'No. rainy days/month'
thetasat_var = nc_file.createVariable('SaturatedWaterContent',
'f8', ('latitude', 'longitude'),
fill_value=-9999)
thetasat_var.long_name = 'Saturated water content (top soil)'
thetasat_var.units = 'cm3/cm3'
rootdepth_var = nc_file.createVariable('RootDepth',
'f8', ('latitude', 'longitude'),
fill_value=-9999)
rootdepth_var.long_name = 'Root depth'
rootdepth_var.units = 'mm'
basinmask_var = nc_file.createVariable('BasinBuffer',
'l', ('latitude', 'longitude'),
fill_value=0)
basinmask_var.long_name = 'Basin buffer'
# Load data
lat_var[:] = lat_ls
lon_var[:] = lon_ls
month_var[:] = time_ls
year_var[:] = years_ls
# Static variables
temp_dir = tempfile.mkdtemp()
# Theta sat
print "{0}\t{1}".format('thetasat', thetasat_ras)
thetasat_temp = os.path.join(temp_dir, 'thetasat.tif')
arcpy.management.Resample(thetasat_ras, thetasat_temp, cellsize)
inp_ras = arcpy.Raster(thetasat_temp)
array = arcpy.RasterToNumPyArray(inp_ras, ll_corner, lon_n, lat_n, -9999)
thetasat_var[:, :] = array[:, :]
# Root depth
print "{0}\t{1}".format('rootdepth', rootdepth_ras)
rootdepth_temp = os.path.join(temp_dir, 'rootdepth.tif')
arcpy.management.Resample(rootdepth_ras, rootdepth_temp, cellsize)
inp_ras = arcpy.Raster(rootdepth_temp)
array = arcpy.RasterToNumPyArray(inp_ras, ll_corner, lon_n, lat_n, -9999)
rootdepth_var[:, :] = array[:, :]
# Basin mask
inp_ras = arcpy.sa.Con(arcpy.sa.IsNull(arcpy.Raster(basin_ras)), 0, 1)
array = arcpy.RasterToNumPyArray(inp_ras, ll_corner, lon_n, lat_n, -9999)
basinmask_var[:, :] = array[:, :]
# Dynamic variables
for var in ['p', 'et', 'eto', 'lai', 'swi', 'swio', 'swix', 'rainydays']:
# Make temp directory
temp_dir2 = tempfile.mkdtemp()
for yyyymm in time_ls:
yyyy = yyyymm[:4]
mm = yyyymm[-2:]
ras = all_paths[var].format(yyyy=yyyy, mm=mm)
print "{0}\t{1}".format(var, ras)
arcpy.management.Resample(
ras, os.path.join(temp_dir2, os.path.basename(ras)), cellsize,
'NEAREST')
inp_ras = arcpy.Raster(
os.path.join(temp_dir2, os.path.basename(ras)))
array = arcpy.RasterToNumPyArray(inp_ras, ll_corner, lon_n, lat_n,
pd.np.nan)
t_index = time_ls.index(yyyymm)
exec('{0}_var[t_index, :, :] = array[:, :]'.format(var))
# Runoff ratio
temp_dir2 = tempfile.mkdtemp()
for yyyy in years_ls:
ras = all_paths['qratio'].format(yyyy=yyyy)
print "{0}\t{1}".format('qratio', ras)
arcpy.management.Resample(
ras, os.path.join(temp_dir2, os.path.basename(ras)), cellsize,
'NEAREST')
inp_ras = arcpy.Raster(os.path.join(temp_dir2, os.path.basename(ras)))
array = arcpy.RasterToNumPyArray(inp_ras, ll_corner, lon_n, lat_n,
pd.np.nan)
y_index = years_ls.index(yyyy)
qratio_var[y_index, :, :] = array[:, :]
# Calculate yearly rasters
for yyyy in years_ls:
yyyyi = years_ls.index(yyyy)
ti1 = time_indeces[yyyy][0]
ti2 = time_indeces[yyyy][-1] + 1
py_var[yyyyi, :, :] = pd.np.sum(p_var[ti1:ti2, :, :], axis=0)
ety_var[yyyyi, :, :] = pd.np.sum(et_var[ti1:ti2, :, :], axis=0)
# Close file
arcpy.env.extent = None
arcpy.env.snapRaster = None
arcpy.env.cellSize = 'MAXOF'
nc_file.close()
# Return
return input_nc
def MFRC(option,pic,pathIMERG, path3Mean, pathOutput, pathGWR,fileName):
timeOfprocess = time.clock()
# option='MF' #'MFn' 'MFn-GWR' 控制选择一种分形
# pic='Y' # 'N' 控制是否制作特征图
dimension = 2
branch = 2
m = 50 #随机级联的次数
n = 4 #每次级联的层数
# "经常修改的参数"
fileName = fileName
# path = pathIMERG
pathIMERG= pathIMERG
path3Mean= path3Mean
pathResultRaster=pathOutput+'Rasters/'
pathAnalysis=pathOutput+'Analysis/'
# 此处应留GWR数据的操作
if (option=='MFn-GWR'):
pathGWR=''
q = np.linspace(-10, 10, 21) # "q取值范围"
# 读入栅格数据
rasIMERG = arcpy.Raster(pathIMERG)
ras3Mean = arcpy.Raster(path3Mean)
# Set environmental variables for output
arcpy.env.overwriteOutput = True
arcpy.env.outputCoordinateSystem = rasIMERG
outResolution = 1000
cellWidth = rasIMERG.meanCellWidth/16.0
cellHeight = rasIMERG.meanCellHeight/16.0
lowerLeft = arcpy.Point(rasIMERG.extent.XMin, rasIMERG.extent.YMin)
# Convert Raster to numpy array
arrIMERG = arcpy.RasterToNumPyArray(rasIMERG)
arrIMERG = np.maximum(arrIMERG, 0)
arr3Mean = arcpy.RasterToNumPyArray(ras3Mean)
arr3Mean = np.maximum(arr3Mean, 0)
if (option=='MFn-GWR'):
rasGWR = arcpy.Raster(pathGWR)
arrGWR = arcpy.RasterToNumPyArray(rasGWR)
arrGWR = np.maximum(arrGWR, 0)
# print arrIMERG,'\n\n\n',arr3Mean #arrGWR
# "匀质化"
row = arrIMERG.shape[0]
col = arrIMERG.shape[1]
for i in range(0, row):
for j in range(0, col):
arr3Mean[i,j]=arr3Mean[i,j]/np.sum(arr3Mean)*(row*col)
# print row,col
field = np.empty((row, col), np.float)
for i in range(0, row):
for j in range(0, col):
if (arr3Mean[i, j] > 0):
field[i, j] = arrIMERG[i, j] / arr3Mean[i, j]
else:
field[i, j] = 0
print("field:", np.mean(arrIMERG))
print("field:", np.mean(field))
# field=arrIMERG
# "归一化"
# sumField = np.sum(field)
# if (sumField > 0):
# field = field / sumField
# print field
fieldSize = field.shape[0]
# "layers+1 即向上分析的层数，scales即每层中像元大小对应的起始0.1度时的倍数"
layers = np.arange(0, int(math.log(fieldSize, branch)))
scales = branch ** layers
# print("layers:", layers, "scales:", scales)
# "求统计矩moment"
# "d1用来计算taoq的一阶导(求奇异值alpha和参数beta")，d2用来计算taoq的二阶导（求参数sigma）"
# "d3用来计算D(q)"
moment = np.zeros((len(layers), len(q)))
d1 = np.zeros((len(layers), len(q)))
d2 = np.zeros((len(layers), len(q)))
d3 = np.zeros((len(layers), len(q)))
for i in range(0, len(layers)):
distrib = coarseGraining(field, field.shape // scales[i]) ##[x // scales[i] for x infield.shape]
positiveDist = distrib[distrib > 0]
for j in range(0, len(q)):
qmass = positiveDist ** q[j]
moment[i, j] = np.sum(qmass)
# print"distrib",distrib
# print "q[j]",q[j]
# print "moment[i,j]",moment[i,j]
d1[i, j] = np.sum(qmass * np.log(positiveDist)) / np.sum(qmass)
d2[i, j] = np.sum(qmass * np.log(positiveDist) ** 2) / np.sum(qmass) - d1[i, j] ** 2
if (q[j] != 1):
d3[i, j] = np.log(np.sum(qmass)) / (q[j] - 1)
else:
d3[i, j] = d1[i, j]
lambd = 1.0/ branch ** (4-layers)
print lambd
logMoment = np.log(moment) / np.log(2)
logLambd = np.log(lambd) / np.log(2)
# "证明具有幂律特征"# "求tao(q),tao(q)就是斜率"
k = np.zeros(len(q)) # 存放斜率
b = np.zeros(len(q)) # 存放截距
# R_Squared = np.zeros(len(q)) # 存放R方
# x = np.log(lambd) / np.log(2) # log以2为底的lambda,线性最小二乘的X输入
# X = sm.add_constant(X.T) # 加上截距项
for i in range(0, len(q)):
# y = np.log(moment[:, i]) / np.log(2) # log以2为底的moment，线性最小二乘的X输入
# results = sm.OLS(Y, X).fit() # log以2为底的moment和lambda的线性拟合
line = np.polyfit(logLambd, logMoment[:, i], 1)
k[i] = line[0] # 斜率
b[i] = line[1] # 截距
# R_Squared[i] = results.rsquared
# print("k:", k[i], "b:", b[i], "Rsquared:", R_Squared[i])
# "在多重分形领域taoq就是上面的斜率，与级联降尺度中的taoq不同"
taoq = -k
# "证明具有多重分形特征"#"用多重分形谱f(α)表示"
alpha = np.zeros(len(q))
f_alpha = np.zeros(len(q))
for j in range(0, len(q)):
line = np.polyfit(np.log(lambd), d1[:, j], 1)
alpha[j] = line[0]
f_alpha[j] = alpha[j] * q[j] -k[j]
# "证明具有多重分形特征"# "用广义分形维数D(q)表示"
D_q = np.zeros((len(q)))
for j in range(0, len(q)):
line = np.polyfit(np.log(lambd), d3[:, j], 1)
D_q[j] = line[0]
# "求二阶导，继而计算β和σ，将q=1处作为返回值"
# "由于级联降尺度的研究者，分形尺度仍然从1到5，强行把负号移到了taoq上，所以在Xu等的降尺度中，taoq已经变化，增加来自λ的负号"
# scales = scales[::-1]
# print (scales)
d1taoq = -alpha
d2taoq = np.zeros(len(q))
for j in range(0, len(q)):
d2[:, j] = d2[::, j] #-号
line = np.polyfit(np.log(lambd), d2[:, j], 1)
d2taoq[j] = -line[0]
# print 'taoq的一阶导：',d1taoq,'\n','taoq的二阶导：',d2taoq
e = 0
v = 1
for i in range(0, len(q)):
# print q[i]
if (q[i] >= 1):
if (option == "MF"):
# "X是标准正态分布"
sigma = math.sqrt(d2taoq[i] / (dimension * np.log(branch**2)))
beta = 1 + d1taoq[i] / dimension - sigma ** 2 * np.log(branch ** 2) * (q[i] - 0.5)
else:
# "X是非标准正态分布"
# "需要计算原数据的均值和方差"
data = np.array(arrIMERG).reshape(row * col, 1)
d = []
for j in range(0, row * col):
if data[j, 0] != 0:
d.append(data[j, 0])
e = np.sum(np.log(d) / np.log(2)) / len(d)
v = np.sum((np.log(d) / np.log(2) - e) ** 2) / len(d)
# print("e:", e, "v:", v)
sigma = math.sqrt(d2taoq[i] / (v*dimension * np.log(branch ** 2)))
beta = 1 + d1taoq[i] / dimension - sigma ** 2 * np.log(branch ** 2) * (q[i] - 0.5)
break
print (beta, sigma, e, v)
exportPlot(logLambd,logMoment,k,b,q,alpha,f_alpha,taoq,D_q,pathAnalysis,fileName,pic,beta,sigma,e,v)
timeOfprocess=time.clock() - timeOfprocess
print "多重分形特征分析及参数计算耗时=", timeOfprocess, "秒"
# "实际降尺度并得到结果"
fieldAll = []
cascade = []
for i in range(0, n + 1):
cascade.append(np.zeros((branch ** i, branch ** i), np.double))
# print ("cascade:",cascade)
gamma = beta - sigma * e - v * sigma ** 2 * np.log(branch**2) / 2
# "循环m次"
for k in range(0, m):
for i in range(row):
for j in range(col):
cascade[0][0][0] = field[i, j]
for x in range(1, n + 1):
for y in range(0, branch ** (x - 1)):
for z in range(0, branch ** (x - 1)):
w=np.zeros((4,1),float)
if (random.uniform(0,1)<=(branch**2)**(-beta)):
w[0]=(branch**2) ** (gamma + sigma * random.gauss(e, v))
else:
w[0]=0
if (random.uniform(0,1)<=(branch**2)**(-beta)):
w[1]=(branch**2) ** (gamma + sigma * random.gauss(e, v))
else:
w[1]=0
if (random.uniform(0,1)<=(branch**2)**(-beta)):
w[2]=(branch**2) ** (gamma + sigma * random.gauss(e, v))
else:
w[2]=0
w[3]=4-w[0]-w[1]-w[2]
# print w
cascade[x][y * 2][z * 2] = cascade[x - 1][y][z] * w[0]
cascade[x][y * 2][z * 2 + 1] = cascade[x - 1][y][z] * w[1]
cascade[x][y * 2 + 1][z * 2] = cascade[x - 1][y][z] * w[2]
cascade[x][y * 2 + 1][z * 2 + 1] = cascade[x - 1][y][z] * w[3]
# simfield[:,. :] = coarseGraining(cascade[n], (32, 32))
# print("simfield:",simfield)
if (j == 0):
fieldRow = cascade[n].copy()
else:
fieldRow = np.hstack((fieldRow, cascade[n].copy()))
if (i == 0):
fieldMatrix = fieldRow.copy()
else:
fieldMatrix = np.vstack((fieldMatrix, fieldRow.copy()))
# np.savetxt('F:/Test/OUT/'+"fieldAll"+str(k)+""+".txt",fieldMatrix,fmt = '%.8f')
fieldAll.append(fieldMatrix)
# "求多次结果平均值"
fieldAve = np.zeros((row * 2 ** n, col * 2 ** n), np.double)
for k in range(0, m):
fieldAve = fieldAve + fieldAll[k]
fieldAve = fieldAve / m
# np.savetxt('F:/Test/OUT/'+"fieldAve"+"ave"+".txt", fieldAve,fmt = '%.8f')
# "恢复异质性"
fieldHeter = np.zeros((row * 2 ** n, col * 2 ** n), np.double)
for i in range(0, row):
for j in range(0, col):
if option == 'MFn-GWR':
temp = arrGWR[i * 2 ** n:(i + 1) * 2 ** n, j * 2 ** n:(j + 1) * 2 ** n] \
* fieldAve[ i * 2 ** n:(i + 1) * 2 ** n, j * 2 ** n:(j + 1) * 2 ** n]
else:
temp = arr3Mean[i, j] * fieldAve[i * 2 ** n:(i + 1) * 2 ** n, j * 2 ** n:(j + 1) * 2 ** n]
if (np.sum(temp) != 0):
temp = temp / np.sum(temp)
else:
temp = 0
fieldHeter[i * 2 ** n:(i + 1) * 2 ** n, j * 2 ** n:(j + 1) * 2 ** n] = temp * arrIMERG[i, j] * (
2 ** n * 2 ** n)
# result = np.array(result).reshape(row * 2 ** n * col * 2 ** n, 1)
# np.savetxt(path + 'out/' + "r" + option + ".txt", result, fmt='%.8f')
# 输出数据，制作栅格
tempRaster = arcpy.NumPyArrayToRaster(fieldHeter,lowerLeft,cellWidth,cellHeight)
onekmRaster=pathResultRaster + 'r'+fileName+".tif"
arcpy.Resample_management(tempRaster, onekmRaster, outResolution, "BILINEAR") #"重采样到1km"
timeOfprocess=time.clock() - timeOfprocess
print "降尺度计算耗时=", timeOfprocess, "秒"
pour_point = arcpy.GetParameterAsText(5)
arcpy.AddMessage("-------------------------")
arcpy.AddMessage("Loaded datasets")
arcpy.AddMessage("-------------------------")
# Calculate the cell size of the DTM
DTM_cell_size = arcpy.GetRasterProperties_management(DTM, "CELLSIZEX")
#Get the elevation standard deviation value from geoprocessing result object
cell_size = DTM_cell_size.getOutput(0)
arcpy.AddMessage("Calculated operating cell size")
arcpy.AddMessage("-------------------------")
# Clip the river network to the extent to the same as the DTM
# First calculate the extent of the DTM
pnt_array = arcpy.Array()
extent = arcpy.Raster(DTM).extent
pnt_array.add(extent.lowerLeft)
pnt_array.add(extent.lowerRight)
pnt_array.add(extent.upperRight)
pnt_array.add(extent.upperLeft)
# Turn the extents of the raster into a polygon to clip the river_network
clipping_polygon = arcpy.Polygon(pnt_array)
# Clip the river network to the same as the digital terrain model
river_network = arcpy.Clip_analysis(river_network, clipping_polygon,
"out_river")
# Add fields to the river network polyline
arcpy.AddField_management(river_network, "river_depth", "SHORT")
arcpy.AddField_management(river_network, "river_cell_size", "SHORT")
def calculate_det(self, path2h_ras, path2dem_ras):
try:
arcpy.CheckOutExtension('Spatial') # check out license
arcpy.gp.overwriteOutput = True
arcpy.env.workspace = self.cache
try:
self.logger.info(" * Reading input rasters ...")
ras_h = arcpy.Raster(path2h_ras)
ras_dem = arcpy.Raster(path2dem_ras)
arcpy.env.extent = ras_dem.extent
self.logger.info(" * OK")
except:
self.logger.info(
"ERROR: Could not find / access input rasters.")
return True
try:
self.logger.info(" * Making Thalweg elevation raster ...")
ras_hmin = Con((ras_h > 0.0), Float(ras_dem))
ras_h_with_null = Con((Float(ras_h) > 0.0), Float(ras_h))
temp_dem = Con(((ras_dem > 0) & IsNull(ras_h_with_null)),
Float(ras_dem))
ras_dem = temp_dem
self.logger.info(" * OK")
except:
self.logger.info("ERROR: Input Rasters contain invalid data.")
return True
try:
self.logger.info(" * Converting Thalweg raster to points ...")
pts_hmin = arcpy.RasterToPoint_conversion(
ras_hmin, self.cache + "pts_hmin.shp")
self.logger.info(" * OK")
self.logger.info(" * Converting DEM raster to points ...")
pts_dem = arcpy.RasterToPoint_conversion(
ras_dem, self.cache + "pts_dem.shp")
self.logger.info(" * OK")
except arcpy.ExecuteError:
self.logger.info(arcpy.AddError(arcpy.GetMessages(2)))
return True
except Exception as e:
self.logger.info(arcpy.GetMessages(2))
return True
base_join = self.out_dir + '\\spat_join_det.shp'
try:
self.logger.info(" * Spatial join analysis ...")
base_join = arcpy.SpatialJoin_analysis(
target_features=pts_dem,
join_features=pts_hmin,
out_feature_class=base_join,
join_operation='JOIN_ONE_TO_MANY',
join_type='KEEP_ALL',
match_option='CLOSEST')
self.logger.info(" * OK")
except arcpy.ExecuteError:
self.logger.info(arcpy.AddError(arcpy.GetMessages(2)))
return True
except Exception as e:
self.logger.info(arcpy.GetMessages(2))
return True
try:
self.logger.info(
" * Converting relative Thalweg dem to raster ...")
arcpy.PointToRaster_conversion(in_features=base_join,
value_field="grid_cod_1",
out_rasterdataset=self.cache +
"ras_hmin_dem",
cell_assignment="MEAN",
cellsize=5)
self.logger.info(" * OK")
except arcpy.ExecuteError:
self.logger.info(arcpy.AddError(arcpy.GetMessages(2)))
return True
except Exception as e:
self.logger.info(arcpy.GetMessages(2))
return True
try:
self.logger.info(
" * Calculating depth to Thalweg raster (detrended DEM) ..."
)
ras_hmin_dem = arcpy.Raster(self.cache + "ras_hmin_dem")
ras_det = Con((ras_hmin_dem > 0), (ras_dem - ras_hmin_dem))
self.logger.info(" * OK")
except arcpy.ExecuteError:
self.logger.info(arcpy.AddError(arcpy.GetMessages(2)))
return True
except Exception as e:
self.logger.info(arcpy.GetMessages(2))
return True
try:
self.logger.info(
" * Saving depth to Thalweg raster (detrended DEM) to:\n%s"
% self.out_dir + "\\dem_detrend.tif")
ras_det.save(self.out_dir + "\\dem_detrend.tif")
self.logger.info(" * OK")
except arcpy.ExecuteError:
self.logger.info(arcpy.AddError(arcpy.GetMessages(2)))
return True
except Exception as e:
self.logger.info(arcpy.GetMessages(2))
return True
arcpy.CheckInExtension('Spatial')
except arcpy.ExecuteError:
self.logger.info("ExecuteERROR: (arcpy).")
self.logger.info(arcpy.GetMessages(2))
return True
except Exception as e:
self.logger.info("ExceptionERROR: (arcpy).")
self.logger.info(e.args[0])
return True
try:
del ras_det, ras_hmin, base_join, pts_dem, pts_hmin, ras_hmin_dem
except:
pass
try:
self.clean_up()
except:
pass
# return False if successfull
return False
nb += 1
if __name__ == "__main__":
# Retrive the parameters from the GUI
SlblFile = arcpy.GetParameterAsText(0)
DepthFile = arcpy.GetParameterAsText(1)
ErosionFile = arcpy.GetParameterAsText(2)
outFolder = arcpy.GetParameterAsText(3)
cellFactor = float(arcpy.GetParameterAsText(4))
str_message = 'Saving DAN3D input files...'
arcpy.AddMessage(str_message)
SlblFile = arcpy.Raster(SlblFile)
DepthFile = arcpy.Raster(DepthFile)
if len(ErosionFile) > 0:
Erosion = True
ErosionFile = arcpy.Raster(ErosionFile)
else:
Erosion = False
IncellSize = SlblFile.meanCellWidth
if cellFactor != 1:
cellSize = IncellSize * cellFactor
str_message = "Inputs rasters are being aggreagated. Output cell size will be {}m".format(
cellSize)
arcpy.AddMessage(str_message)
SlblFile = arcpy.sa.Aggregate(SlblFile, cellFactor, "MEDIAN", "EXPAND",
"DATA")
def make_sub_condition(source_condition, target_condition, base_geo_name):
# source_condition = STR of a source condition ("D:\\...\\RiverArchitect\\01_Conditions\\2017\\")
# target_condition = STR of a target condition ("D:\\...\\RiverArchitect\\01_Conditions\\2017_confinement\\")
# base_geo_name = STR of a full path and name of a raster that is used for limiting raster extents ("D:\\...\\Rasters\\projectarea")
logger = logging.getLogger('logfile.log')
logger.info(" * Setting arcpy environment ...")
try:
arcpy.CheckOutExtension('Spatial')
arcpy.env.overwriteOutput = True
arcpy.env.workspace = config.dir2ra
except:
logger.info(
"ERROR: Could not set arcpy environment (permissions and licenses?)."
)
return True
try:
logger.info(" * Verifying provided boundary files ...")
base_geo_name = chk_geo_type(base_geo_name, target_condition)
except:
logger.info("ERROR: The provided boundary file (%s) is invalid." %
base_geo_name)
return True
try:
logger.info(" * Loading boundary Raster ...")
base_ras = arcpy.Raster(base_geo_name.split('.aux')[0])
arcpy.env.extent = base_ras.extent
except:
logger.info("ERROR: Could not load boundary Raster: " +
str(base_geo_name).split('.aux')[0])
return True
logger.info(" * Looking for source GeoTIFFs in %s ..." % source_condition)
geotiff_names = [
i for i in os.listdir(source_condition) if i.endswith('.tif')
]
for gtiff_full_name in geotiff_names:
logger.info(" > Loading " + str(gtiff_full_name) + " ... ")
try:
gtiff_full = arcpy.Raster(source_condition + gtiff_full_name)
except:
logger.info("ERROR: Could not read source file (%s)." %
str(source_condition + gtiff_full_name))
continue
logger.info(" * Cropping raster ... ")
try:
gtiff_cropped = Con(~IsNull(base_ras), Float(gtiff_full))
except:
logger.info("ERROR: Could not crop " + str(gtiff_full_name))
continue
logger.info(" * Saving cropped raster as " + target_condition +
gtiff_full_name + " ... ")
try:
gtiff_cropped.save(target_condition + gtiff_full_name)
logger.info(" * OK")
except:
logger.info("ERROR: Could not save " +
str(target_condition + gtiff_full_name))
arcpy.CheckInExtension('Spatial')
logger.info(" * Spatial Sub-Condition creation complete..")
# return Error=False after successful execution
return False
# The only rule is, you should run your script once, and generate the NVDI for ALL MONTHS provided.
# As part of your code submission, you should also provide a visualization document (e.g. an ArcMap layout),
# showing the patterns for an area of RI that you find interesting.
import arcpy
arcpy.env.workspace=r"C:\Users\17065\OneDrive\Desktop\NRS 528\06_Cheating\ALL_FILES_lfs\Step_3_data_lfs\201502"
# To allow overwriting outputs change overwriteOutput option to True.
arcpy.env.overwriteOutput = True
# Check out any necessary licenses.
arcpy.CheckOutExtension("spatial")
arcpy.CheckOutExtension("ImageAnalyst")
LC08_L1TP_012031_20150201_20170301_01_T1_B5_tif = arcpy.Raster("LC08_L1TP_012031_20150201_20170301_01_T1_B5.tif")
LC08_L1TP_012031_20150201_20170301_01_T1_B4_tif = arcpy.Raster("LC08_L1TP_012031_20150201_20170301_01_T1_B4.tif")
# Process: Raster Calculator (Raster Calculator) (ia)
NDVI = "C:\\Users\\17065\\OneDrive\\Desktop\\NRS 528\\NDVI\\ndvi02"
Raster_Calculator = NDVI
NDVI = nvdi = (LC08_L1TP_012031_20150201_20170301_01_T1_B5_tif-LC08_L1TP_012031_20150201_20170301_01_T1_B4_tif)/(LC08_L1TP_012031_20150201_20170301_01_T1_B5_tif+LC08_L1TP_012031_20150201_20170301_01_T1_B4_tif)
NDVI.save(Raster_Calculator)
arcpy.env.workspace=r"C:\Users\17065\OneDrive\Desktop\NRS 528\06_Cheating\ALL_FILES_lfs\Step_3_data_lfs\201504"
# To allow overwriting outputs change overwriteOutput option to True.
arcpy.env.overwriteOutput = True
def save(self):
# Set environmental variables for output
arcpy.env.outputCoordinateSystem = self.rasterlike.catalogPath
arcpy.env.cellSize = self.rasterlike.catalogPath
# Loop over data blocks
filelist = []
blockno = 0
randomname = binascii.hexlify(os.urandom(6))
picklefilename = arcpy.env.scratchWorkspace + "\\" + randomname + ".pkl"
pickledict = open(picklefilename, 'wb')
pickle.dump(self.dict, pickledict)
pickledict.close()
for x in range(0, self.rasterlike.width, self.blocksize):
for y in range(0, self.rasterlike.height, self.blocksize):
# Save on disk with a random name
randomname = binascii.hexlify(os.urandom(6))
filetemp = arcpy.env.scratchWorkspace + "\\" + randomname
if self.raster is not None:
startcmd = "python.exe \""+sys.path[0].encode('utf-8')+"\\RasterIO.py\"" \
+ " -rasterlike \"" + self.rasterlike.catalogPath.encode('utf-8') + "\""\
+ " -x " + str(x) \
+ " -y " + str(y) \
+ " -blocksize " + str(self.blocksize) \
+ " -blockname \"" + str(filetemp) + "\""\
+ " -nodata " + str(self.nodata) \
+ " -dtype " + str(self.dtype.__name__) \
+ " -pickledict \"" + picklefilename.encode('utf-8') + "\""\
+ " -raster \"" + self.raster.catalogPath.encode('utf-8') + "\""
else:
startcmd = "python.exe \""+sys.path[0].encode('utf-8')+"\\RasterIO.py\"" \
+ " -rasterlike \"" + self.rasterlike.catalogPath.encode('utf-8') + "\""\
+ " -x " + str(x) \
+ " -y " + str(y) \
+ " -blocksize " + str(self.blocksize) \
+ " -blockname \"" + str(filetemp) + "\""\
+ " -nodata " + str(self.nodata) \
+ " -dtype " + str(self.dtype.__name__) \
+ " -pickledict \"" + picklefilename.encode('utf-8') + "\""
FNULL = open(os.devnull, 'w')
si = subprocess.STARTUPINFO()
si.dwFlags = subprocess.STARTF_USESHOWWINDOW
si.wShowWindow = subprocess.SW_HIDE
subprocess.check_call(startcmd, startupinfo=si, stdout=FNULL, stderr=subprocess.STDOUT)
# Maintain a list of saved temporary files
filelist.append(filetemp)
blockno += 1
os.remove(picklefilename)
if arcpy.Exists(self.fileout):
arcpy.Delete_management(self.fileout)
if len(filelist) > 1:
# Mosaic temporary files
rastertype = {"U1": "1_BIT",
"U2": "2_BIT",
"U4": "4_BIT",
"U8": "8_BIT_UNSIGNED",
"S8": "8_BIT_SIGNED",
"U16": "16_BIT_UNSIGNED",
"S16": "16_BIT_SIGNED",
"U32": "32_BIT_UNSIGNED",
"S32": "32_BIT_SIGNED",
"F32": "32_BIT_FLOAT",
"F64": "64_BIT_FLOAT"}
arcpy.MosaicToNewRaster_management(';'.join(filelist), os.path.dirname(os.path.abspath(self.fileout)),
os.path.basename(self.fileout),
pixel_type=rastertype[arcpy.Raster(filelist[0]).pixelType],
number_of_bands=1)
else:
arcpy.Copy_management(filelist[0], self.fileout)
# if len(filelist) > 1:
# # Mosaic temporary files
# arcpy.Mosaic_management(';'.join(filelist[1:]), filelist[0])
#
# arcpy.Copy_management(filelist[0], self.fileout)
# Remove temporary files
for fileitem in filelist:
if arcpy.Exists(fileitem):
arcpy.Delete_management(fileitem)
self.raster = arcpy.Raster(self.fileout)
if self.raster.pixelType == "U1":
self.dtype = bool
elif self.raster.pixelType == "F32" or self.raster.pixelType == "F64":
self.dtype = float
else:
self.dtype = int
arcpy.DefineProjection_management(self.raster, self.rasterlike.spatialReference)
