# raster. Of course you could do this using Raster Calculator, but what if you want to do more complex statistics,
# model simulations and so on?
# Be aware that the size of the raster is crucial as the resulting numpy array will reside in your computer
# memory, so no 10gb files!
import arcpy
arcpy.env.overwriteOutput = True
arcpy.env.workspace = r"C:\Data\Course_ArcGIS_Python\Classes\10_Rasters\DataFolder\Step_2_Data"
inRas = arcpy.Raster("etopo10")
lowerLeft = arcpy.Point(inRas.extent.XMin, inRas.extent.YMin)
cellSize = inRas.meanCellWidth
arr = arcpy.RasterToNumPyArray(inRas, nodata_to_value=0)
# Print the resulting array
print(arr.shape)
# Now lets convert m to feet
arrFeet = arr * 3.28084
newRaster = arcpy.NumPyArrayToRaster(arrFeet,
lowerLeft,
cellSize,
value_to_nodata=0)
newRaster.save("etopo10_ft.tif")
# Task: Using the etopo10 dataset and a NumPyArray, extract only land values, replacing them with null data and
# create the resulting tif file. Hint: arr[arr < 0] = -9999
## Output File creation
# Output raster file names and locations
dataCountOut = os.path.join(outputFolder, r"dataCount.tif")
if linRegBool == "true":
linReg_slopeOut = os.path.join(outputFolder, r"linReg_slope.tif")
linReg_pvalueOut = os.path.join(outputFolder, r"linReg_pvalue.tif")
linReg_stderrOut = os.path.join(outputFolder, r"linReg_std_err.tif")
if theilSenBool == "true":
theilSen_slopeOut = os.path.join(outputFolder, r"theilSen_slope.tif")
theilSen_loSlopeOut = os.path.join(outputFolder, r"theilSen_loSlope.tif")
theilSen_upSlopeOut = os.path.join(outputFolder, r"theilSen_upSlope.tif")
# Save outpu files
output_r = arcpy.NumPyArrayToRaster(dataCount_rast, lowerLeft,
arcRast(inputRastDir, 1).meanCellWidth,
arcRast(inputRastDir, 1).meanCellHeight,
noData)
output_r.save(dataCountOut)
if linRegBool == "true":
output_r = arcpy.NumPyArrayToRaster(
linReg_slope, lowerLeft,
arcRast(inputRastDir, 1).meanCellWidth,
arcRast(inputRastDir, 1).meanCellHeight, noData)
output_r.save(linReg_slopeOut)
output_r = arcpy.NumPyArrayToRaster(
linReg_pvalue, lowerLeft,
arcRast(inputRastDir, 1).meanCellWidth,
arcRast(inputRastDir, 1).meanCellHeight, noData)
output_r.save(linReg_pvalueOut)
output_r = arcpy.NumPyArrayToRaster(
linReg_std_err, lowerLeft,
# --------------------------
# processing
r = Raster(rasterPath) # open the raster
# calcuate
max = r.maximum # get the maximum of this raster
min = r.minimum # get the minimum of this raster
d = (max - min) / groupCnt # the distance
array = arcpy.RasterToNumPyArray(r) # the Raster to NumPy
rowNum, colNum = array.shape
for i in range(0, rowNum):
for j in range(0, colNum):
value = array[i][j]
if value == max: # the value of max is specific
array[i][j] = groupCnt + startingNum - 1
continue
cnt = groupCnt - 1
while cnt != -1:
if value >= min + d * cnt:
array[i][j] = cnt + 1
break
cnt = cnt - 1
# save raster from numpy
lowerLeft = arcpy.Point(r.extent.XMin, r.extent.YMin)
cellSize = r.meanCellWidth
newRaster = arcpy.NumPyArrayToRaster(array, lowerLeft, cellSize)
newRaster.save(outPath)
bandArray = npy.zeros(inArray.shape, dtype='int32')
stripeArray = bandArray.copy()
header = get_header(raster)
outDir, rasterName = os.path.split(raster)
bandRasterPath = os.path.join(
outDir, resisRasterBase + '_bandsBlockSize' + str(blockSize) + '.tif')
stripeRasterPath = os.path.join(
outDir, resisRasterBase + '_stripesBlockSize' + str(blockSize) + '.tif')
bandNum = 0
stripeNum = 0
print 'Processing', raster
for centerRow in range((blockSize - 1) / 2, header['nrows'], blockSize):
bandNum += 1
bandArray[centerRow - (blockSize - 1) / 2:centerRow + (blockSize - 1) / 2 +
1, :] = bandNum
LLC = arcpy.Point(header['xllcorner'], header['yllcorner'])
bandRaster = arcpy.NumPyArrayToRaster(bandArray, LLC, header['cellsize'],
header['cellsize'], -9999)
bandRaster.save(bandRasterPath)
print 'Saved', bandRasterPath
for centerCol in range((blockSize - 1) / 2, header['ncols'], blockSize):
stripeNum += 1
stripeArray[:, centerCol - (blockSize - 1) / 2:centerCol +
(blockSize - 1) / 2 + 1] = stripeNum
stripeRaster = arcpy.NumPyArrayToRaster(stripeArray, LLC, header['cellsize'],
header['cellsize'], -9999)
stripeRaster.save(stripeRasterPath)
print 'Saved', stripeRasterPath
#Collect initial environment states
initMask = arcpy.env.mask
#Convert the raw bin file to an array (NSIDC ice vector data are 361x361x3 arrays)
with open(moFile, 'rb') as inFile:
arrMO = np.fromfile(inFile, np.int16).reshape(361, 361, 3)
#Extract u/v arrays and reshape to 1D data vectors
uValues = arrMO[:, :, 0].reshape(-1).astype(np.float)
vValues = arrMO[:, :, 1].reshape(-1).astype(np.float)
#Compute magnitudes (via pythagorean theorem)
mValues = np.sqrt(np.square(uValues) + np.square(vValues))
#Create a mask from the 3rd band
maskRaster = arcpy.NumPyArrayToRaster(arrMO[:, :, 2], lowerleft, 25000,
25000, 0)
arcpy.env.mask = maskRaster
#Save u/v/magnitude arrays as 3-band raster
uRaster = arcpy.NumPyArrayToRaster(uValues.reshape(361, 361), lowerleft,
cellSize, cellSize)
vRaster = arcpy.NumPyArrayToRaster(vValues.reshape(361, 361), lowerleft,
cellSize, cellSize)
mRaster = arcpy.NumPyArrayToRaster(mValues.reshape(361, 361), lowerleft,
cellSize, cellSize)
arcpy.CompositeBands_management((uRaster, vRaster, mRaster), outUVRasterFN)
arcpy.DefineProjection_management(outUVRasterFN, srEASE)
#Compute the arctan of above to get the angle, in radians
thetaRadians = np.arctan2(vValues, uValues)
def execute_task(args):
in_extentDict, data, traj_list, noncroplist, croplist, cls, rws = args
fc_count = in_extentDict[0]
###get the extent from the SPECIFIC tile
procExt = in_extentDict[1]
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
arcpy.env.snapRaster = data['pre']['traj']['path']
arcpy.env.cellsize = data['pre']['traj']['path']
arcpy.env.outputCoordinateSystem = data['pre']['traj']['path']
###set the extent for this SPECIFIC tile
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
print 'rws==================================',rws
print 'cls==================================',cls
##create an empty matrix that will be filled with values using the code below if conditions are met
outData = np.zeros((rws, cls), dtype=np.uint16)
print 'outdata', outData
### create numpy arrays for input datasets cdls and traj
cdls = {
2008:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2008', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2009:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2009', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2010:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2010', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2011:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2011', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2012:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2012', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2013:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2013', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2014:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2014', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2015:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2015', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2016:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2016', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls),
2017:arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2017', lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls)
}
###this is the trajectory that is referenced with the specific trajectory values we are looking for from the sql statement above
arr_traj = arcpy.RasterToNumPyArray(in_raster=data['pre']['traj']['path'], lower_left_corner = arcpy.Point(XMin,YMin), nrows = rws, ncols = cls)
#### find the location of each pixel labeled with specific arbitray value in the rows list
#### note the traj_list is derived from the sql query above
for traj in traj_list:
###
traj_value = traj[0]
mtr = traj[1]
traj_array = traj[2]
#Return the indices of the pixels that have values of the ytc arbitray values of the traj.
indices = (arr_traj == traj_value).nonzero()
#stack the indices variable above so easier to work with
stacked_indices=np.column_stack((indices[0],indices[1]))
##### get the x and y location of each pixel that has been selected from above
for pixel_location in stacked_indices:
row = pixel_location[0]
col = pixel_location[1]
### attach the cdl values to each binary trajectory at each pixel location
entirelist = []
for year in data['global']['years']:
entirelist.append(cdls[year][row][col])
### if 61 in the entirelist AND the entirelist does not start with 61 then process the entirelist otherwise skip processing of pixel
if(61 in entirelist):
# print 'entirelist---', entirelist
current_index=entirelist.index(61)
beforelist=np.array(entirelist[:current_index])
# print 'beforelist---', beforelist
afterlist=np.array(entirelist[current_index:])
# print 'afterlist---', afterlist
### remove the first for elements from traj_array
traj_array_before = traj_array[:current_index]
##make sure that there are at least two elements in the beforelist(i.e 2 elements before the first 61)-----length of 2 means yfc is 2010
if(beforelist.size >= 2):
#### Conditions ################################################
## only uniques elements -1 and 0 in numpy diff list to make sure change is only in one direction (ie 1 to 0)
cond1 = np.isin(np.diff(traj_array_before), [-1,0]).all()
## make sure that the first two elements in beforelist are crop ----- this works with cond1
cond2 = traj_array_before[0] == 1 and traj_array_before[1] == 1
## make sure that afterlist contains only noncrop and 61
cond3 = np.isin(afterlist, noncroplist + [61]).all()
## make sure that the afterlist length is greater than 1
cond4 = afterlist.size > 1
if(cond1 and cond2 and cond3 and cond4):
##### label the pixel with conversion year ##############################################
outData[row,col] = data['global']['years'][getIndex(traj_array_before)]
arcpy.ClearEnvironment("extent")
outname = "tile_" + str(fc_count) +'.tif'
outpath = os.path.join("C:/Users/Bougie/Desktop/Gibbs/data/", r"tiles", outname)
myRaster = arcpy.NumPyArrayToRaster(outData, lower_left_corner=arcpy.Point(XMin, YMin), x_cell_size=30, y_cell_size=30, value_to_nodata=0)
##free memory from outdata array
outData = None
myRaster.save(outpath)
myRaster = None
def execute_task(in_extentDict):
fc_count = in_extentDict[0]
procExt = in_extentDict[1]
# print procExt
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
arcpy.env.snapRaster = data['pre']['traj']['path']
arcpy.env.cellsize = data['pre']['traj']['path']
arcpy.env.outputCoordinateSystem = data['pre']['traj']['path']
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
cls = 21973
rws = 13789
# outData = numpy.zeros((rows,cols), numpy.int16)
outData = np.zeros((13789, 21973), dtype=np.int)
### create numpy arrays for input datasets nlcds and traj
# arcpy.RasterToNumPyArray(in_raster='C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\binaries.gdb\\cdl30_b_2007_resampled', lower_left_corner = arcpy.Point(XMin,YMin), nrows = 13789, ncols = 21973),
cdls = {
2007:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\binaries.gdb\\cdl30_b_2007_resampled',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973,
nodata_to_value=255)
}
arr_traj = arcpy.RasterToNumPyArray(in_raster=data['pre']['traj']['path'],
lower_left_corner=arcpy.Point(
XMin, YMin),
nrows=13789,
ncols=21973)
#### find the location of each pixel labeled with specific arbitray value in the rows list
#### note the traj_list is derived from the sql query above
for row in traj_list:
#trajectory value
traj = row[0]
#conversion year ytc
ytc = row[1]
# print 'ytc', ytc
yfc = row[2]
# print 'yfc', yfc
#Return the indices of the pixels that have values of the ytc arbitray values of the traj.
indices = (arr_traj == row[0]).nonzero()
#stack the indices variable above so easier to work with
stacked_indices = np.column_stack((indices[0], indices[1]))
#get the x and y location of each pixel that has been selected from above
for pixel_location in stacked_indices:
row = pixel_location[0]
col = pixel_location[1]
if ytc == 2009 and cdls[2007][row][col] == 1:
# print cdls[2007][row][col]
outData[row, col] = data['refine']['arbitrary_crop']
elif yfc == 2009 and cdls[2007][row][col] == 0:
# print cdls[2007][row][col]
outData[row, col] = data['refine']['arbitrary_noncrop']
arcpy.ClearEnvironment("extent")
outname = "tile_" + str(fc_count) + '.tif'
# #create
outpath = os.path.join("C:/Users/Bougie/Desktop/Gibbs/", r"tiles", outname)
# NumPyArrayToRaster (in_array, {lower_left_corner}, {x_cell_size}, {y_cell_size}, {value_to_nodata})
myRaster = arcpy.NumPyArrayToRaster(outData,
lower_left_corner=arcpy.Point(
XMin, YMin),
x_cell_size=30,
y_cell_size=30,
value_to_nodata=0)
myRaster.save(outpath)
raster_ref = result_table.getRow(0)[1:-1]
arcpy.AddMessage("\nRaster reference is " + str(raster_ref))
spatial = arcpy.Describe(raster_ref).spatialReference
cell_size_x = str(
arcpy.GetRasterProperties_management(raster_ref, "CELLSIZEX"))
cell_size_y = str(
arcpy.GetRasterProperties_management(raster_ref, "CELLSIZEY"))
x_min = str(arcpy.GetRasterProperties_management(raster_ref, "LEFT"))
y_min = str(arcpy.GetRasterProperties_management(raster_ref, "BOTTOM"))
outRaster = arcpy.NumPyArrayToRaster(outGrid,
x_cell_size=float(cell_size_x),
y_cell_size=float(cell_size_y),
lower_left_corner=arcpy.Point(
x_min, y_min),
value_to_nodata=0)
arcpy.DefineProjection_management(outRaster, spatial)
outRaster.save(output)
except Exception as e:
# If unsuccessful, end gracefully by indicating why
arcpy.AddError('\n' + "Script failed because: \t\t" + e.message)
# ... and where
exceptionreport = sys.exc_info()[2]
fullermessage = traceback.format_tb(exceptionreport)[0]
arcpy.AddError("at this location: \n\n" + fullermessage + "\n")
def long_time_task(FID):
'''
处理一个FID，也就是一个2度网格的城市阈值计算，提取，和镶嵌。
'''
# arcpy的临时输出文件
# --- 这段代码保证，不同的arcpy进程使用不同的临时空间，在多进程的环境下避免一些错误
newTempDir = u"./tmp/tmp" + time.strftime('%Y%m%d%H%M%S') + str(FID)
os.makedirs(newTempDir)
os.environ["TEMP"] = newTempDir
os.environ["TMP"] = newTempDir
# ---
for row in arcpy.SearchCursor(config['fc'], '"FID" = {0}'.format(FID)):
begin_time = time.time()
grid_code = int(row.getValue("grid_id")) # 10度网格号
mask = row.getValue("Shape") # 2度网格shape
row_code = row.getValue("code") # 2度网格号
print '**** PID: ' + str(os.getpid()) + ' FID: ' + str(
FID) + " grid_code: " + str(grid_code)
target_area = row.getValue(config['target_count_field']) # 目标城市数目字段
threshold_max = config['threshold_max']
threshold_min = config['threshold_min']
threshold_step = config['threshold_step']
nuaci_path = '{0}/{1}{2}.tif'.format(config['in_folder_path'],
config['input_prefix'], grid_code)
# if not arcpy.Exists(nuaci_path):
# # arcpy.AddError(nuaci_path + ' not found ')
print '####input', nuaci_path
in_raster = Raster(nuaci_path)
in_raster_mask = ExtractByMask(in_raster, mask)
del in_raster
lower_left = arcpy.Point(in_raster_mask.extent.XMin,
in_raster_mask.extent.YMin)
cell_size = in_raster_mask.meanCellWidth
dsc = arcpy.Describe(in_raster_mask)
sr = dsc.SpatialReference
no_data_value = in_raster_mask.noDataValue
in_raster_arr = arcpy.RasterToNumPyArray(in_raster_mask,
nodata_to_value=no_data_value)
del in_raster_mask
actual_area = 0
threshold_value = threshold_max
in_raster_arr_bi = in_raster_arr > threshold_value
while (actual_area < target_area) and (threshold_value >=
threshold_min):
in_raster_arr_bi = in_raster_arr > threshold_value
actual_area = in_raster_arr_bi.sum() * 0.0009
threshold_value -= threshold_step
print('------------final area = ' + str(actual_area) +
'---------------' + str(row_code))
print('final threshold = ' +
str(min([threshold_max, threshold_value + threshold_step])))
in_raster_arr_dtype = in_raster_arr.dtype
del in_raster_arr
in_raster_arr_bi = in_raster_arr_bi.astype(in_raster_arr_dtype)
new_raster = arcpy.NumPyArrayToRaster(in_raster_arr_bi, lower_left,
cell_size, cell_size,
no_data_value)
del in_raster_arr_bi
arcpy.DefineProjection_management(new_raster, sr)
out_raster_path = '{0}/{1}{2}.tif'.format(config['out_folder_path'],
config['output_prefix'],
grid_code)
arcpy.Mosaic_management(new_raster, out_raster_path, "LAST", "FIRST",
"", "", "", "", "")
del new_raster
print 'Task %d - %d - %d runs %0.2f seconds.' % (
os.getpid(), FID, grid_code, (time.time() - begin_time))
def connect_wet_segments(valley_raster, water_ele_raster, wet_raster, flowdir_raster, ele_raster, \
width_raster, order_raster, connected_wet_raster, max_gap, pix_per_m):
corner = arcpy.Point(arcpy.Describe(valley_raster).Extent.XMin, arcpy.Describe(valley_raster).Extent.YMin)
dx = arcpy.Describe(valley_raster).meanCellWidth
valley = arcpy.RasterToNumPyArray(valley_raster, nodata_to_value=0).astype(np.uint8)
dep_ele = arcpy.RasterToNumPyArray(water_ele_raster, nodata_to_value=0)
wet = arcpy.RasterToNumPyArray(wet_raster, nodata_to_value=0).astype(np.uint8)
ele = arcpy.RasterToNumPyArray(ele_raster, nodata_to_value=0)
width = arcpy.RasterToNumPyArray(width_raster, nodata_to_value=0)
width = np.where(wet == 1, width, 0)
dep_ele = np.where(wet == 1, dep_ele, 0)
Lab_wet, num_label_wet = ndimage.label(wet, structure=np.ones((3, 3)))
# find dry and wet valley
tran = disconnect_valley_segments(valley_raster, flowdir_raster, 3, order_raster)
dry_valley = np.where((valley == 1) & (wet == 0), 1, 0).astype(np.uint8)
wet_valley = np.where((valley == 1) & (wet == 1), 1, 0).astype(np.uint8)
temp_dry_valley = ndimage.binary_dilation(dry_valley, iterations=1, structure=np.ones((3, 3))).astype(np.uint8)
dry_valley = np.where(((wet_valley == 1) & (temp_dry_valley == 1)) | (dry_valley == 1), 1, 0).astype(np.uint8)
dry_valley = np.where(tran == 1, 0, dry_valley).astype(np.uint8)
del temp_dry_valley
Lab_dry, num_label_dry = ndimage.label(dry_valley, structure=np.ones((3, 3)))
labels = np.arange(1, num_label_dry + 1)
# 1. connection of dry segments
num_conn_label = ndimage.labeled_comprehension(Lab_wet, Lab_dry, labels, count_unique, int, 0)
num_conn = np.zeros_like(wet)
num_conn = num_conn_label[Lab_dry - 1]
num_conn = np.where(Lab_dry == 0, 0, num_conn)
conn_dry_valley = np.where(num_conn >= 3, 1, 0)
del num_conn, num_conn_label
# 2. elevation of dry segments
Lab_dry, num_label_dry = ndimage.label(conn_dry_valley, structure=np.ones((3, 3)))
labels = np.arange(1, num_label_dry + 1)
ave_ele_label = ndimage.labeled_comprehension(dep_ele, Lab_dry, labels, np.max, float, 0)
max_ele_label = ndimage.labeled_comprehension(ele, Lab_dry, labels, np.max, float, 0)
diff_ele = np.zeros_like(ele)
diff_ele = ave_ele_label[Lab_dry - 1] - max_ele_label[Lab_dry - 1]
diff_ele = np.where(Lab_dry == 0, 0, diff_ele)
conn_dry_valley = np.where(diff_ele < 0, 0, conn_dry_valley)
del diff_ele, max_ele_label, ave_ele_label
# 3. length of dry segment
Lab_dry, num_label_dry = ndimage.label(conn_dry_valley, structure=np.ones((3, 3)))
labels = np.arange(1, num_label_dry + 1)
area_gap_label = ndimage.labeled_comprehension(conn_dry_valley, Lab_dry, labels, np.sum, float, 0) * pix_per_m ** 2
area_dry = np.zeros_like(ele)
area_dry = area_gap_label[Lab_dry - 1]
area_dry = np.where((Lab_dry == 0), 0, area_dry)
conn_dry_valley = np.where(area_dry > max_gap, 0, conn_dry_valley)
del area_dry, ele
# find width of added segments
Lab_dry, num_label_dry = ndimage.label(conn_dry_valley, structure=np.ones((3, 3)))
labels = np.arange(1, num_label_dry + 1)
width_gap_label = ndimage.labeled_comprehension(width, Lab_dry, labels, np.sum, float, 0)
num_conn_label = ndimage.labeled_comprehension(Lab_wet, Lab_dry, labels, count_unique, int, 0)
width_conn = np.zeros_like(width)
width_conn = (width_gap_label[Lab_dry - 1] / num_conn_label[Lab_dry - 1]).astype(np.float32)
width_conn = np.where(Lab_dry == 0, 0, width_conn)
add_wet = add_width(width_conn)
wet = np.where((add_wet == 1) | (wet == 1), 1, 0)
arcpy.NumPyArrayToRaster(wet, corner, dx, dx).save(connected_wet_raster)
def execute_task(args):
in_extentDict, data, nc_list = args
fc_count = in_extentDict[0]
procExt = in_extentDict[1]
# print procExt
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
#The brilliant thing here is that using the extents with the full dataset!!!!!! DONT EVEN NEED TO CLIP THE FULL RASTER TO THE FISHNET BECASUE
arcpy.env.snapRaster = data['pre']['traj']['path']
arcpy.env.cellsize = data['pre']['traj']['path']
arcpy.env.outputCoordinateSystem = data['pre']['traj']['path']
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
cls = 21973
rws = 13789
# outData = numpy.zeros((rows,cols), numpy.int16)
outData = np.zeros((13789, 21973), dtype=np.int)
### create numpy arrays for input datasets cdls and traj
cdls = {
2008:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2008',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2009:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2009',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2010:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2010',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2011:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2011',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2012:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2012',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2013:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2013',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2014:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2014',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2015:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2015',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2016:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2016',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
2017:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2017',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973)
}
arr_traj = arcpy.RasterToNumPyArray(in_raster=data['pre']['traj']['path'],
lower_left_corner=arcpy.Point(
XMin, YMin),
nrows=13789,
ncols=21973)
# find the location of each pixel labeled with specific arbitray value in the rows list
for row in createReclassifyList(data):
#year of conversion for either expansion or abandonment
fc = data['global']['years_conv']
print 'fc', fc
#year before conversion for either expansion or abandonment
bfc = data['global']['years_conv'] - 1
print 'bfc', bfc
#Return the indices of the pixels that have values of the fc arbitrsy values of the traj.
indices = (arr_traj == row[0]).nonzero()
#stack indices so easier to work with
stacked_indices = np.column_stack((indices[0], indices[1]))
#get the x and y location of each pixel that has been selected from above
for pixel_location in stacked_indices:
row = pixel_location[0]
col = pixel_location[1]
#get the pixel value for fc
pixel_value_fc = cdls[fc][row][col]
#get the pixel value for bfc
pixel_value_bfc = cdls[bfc][row][col]
##### create dev mask ##################################################################################
if pixel_value_bfc in [122, 123, 124]:
outData[row, col] = data['refine']['arbitrary_noncrop']
##### create 36_61 mask ################################################################################
if pixel_value_fc in [36, 61]:
#find the years still left in the time series for this pixel location
yearsleft = [i for i in data['global']['years'] if i > fc]
#create templist to hold the rest of the cld values for the time series. initiaite it with the first cdl value
templist = [pixel_value_fc]
for year in yearsleft:
templist.append(cdls[year][row][col])
#if the templist values are esentailly all "noncrop" then realbel as noncrop
if len(set(np.isin(templist, nc_list))) == 1:
outData[row, col] = data['refine']['arbitrary_noncrop']
arcpy.ClearEnvironment("extent")
outname = "tile_" + str(fc_count) + '.tif'
# #create
outpath = os.path.join("C:/Users/Bougie/Desktop/Gibbs/", r"tiles", outname)
# NumPyArrayToRaster (in_array, {lower_left_corner}, {x_cell_size}, {y_cell_size}, {value_to_nodata})
myRaster = arcpy.NumPyArrayToRaster(outData,
lower_left_corner=arcpy.Point(
XMin, YMin),
x_cell_size=30,
y_cell_size=30,
value_to_nodata=0)
myRaster.save(outpath)
def depth_cal(wet_raster, width_raster, ele_raster, pix_per_m, min_slope, max_slope, min_pos_slope,
wet_pos_depth_raster, water_ele_raster):
corner = arcpy.Point(arcpy.Describe(wet_raster).Extent.XMin, arcpy.Describe(wet_raster).Extent.YMin)
dx = arcpy.Describe(wet_raster).meanCellWidth
org_wet = arcpy.RasterToNumPyArray(wet_raster, nodata_to_value=0)
wet = ndimage.morphology.binary_fill_holes(org_wet).astype(np.uint8)
ele = arcpy.RasterToNumPyArray(ele_raster, nodata_to_value=0)
common_border = find_sep_border(org_wet, 7, corner, dx)
wet = ndimage.binary_dilation(org_wet, iterations=2).astype(np.uint8)
wet = np.where(common_border == 1, 0, wet)
common_border = find_sep_border(wet, 7, corner, dx)
wet = ndimage.morphology.binary_fill_holes(wet).astype(np.uint8)
wet = np.where(common_border == 1, 0, wet)
wet = np.where(org_wet == 1, 1, wet)
er_wet_1 = ndimage.binary_erosion(wet).astype(np.uint8)
bound_1 = np.where((wet == 1) & (er_wet_1 == 0), 1, 0).astype(np.uint8)
ele_1 = np.where(bound_1 == 1, ele, 0)
temp_ele_1 = arcpy.NumPyArrayToRaster(ele_1, corner, dx, dx, value_to_nodata=0)
ele_1_thick = FocalStatistics(temp_ele_1, NbrRectangle(3, 3, "CELL"), "MEAN", "DATA")
del ele_1
er_wet_2 = ndimage.binary_erosion(er_wet_1).astype(np.uint8)
bound_2 = np.where((er_wet_1 == 1) & (er_wet_2 == 0), 1, 0).astype(np.uint8)
ele_2 = np.where(bound_2 == 1, ele, 0)
ele_1 = arcpy.RasterToNumPyArray(ele_1_thick, nodata_to_value=0)
ele_1 = np.where(bound_2 == 0, 0, ele_1)
slope = (ele_1 - ele_2) / pix_per_m
slope_sign = np.where(slope > 0, 1, 0)
Lab_wet, num_label = ndimage.label(wet, structure=np.ones((3, 3)))
labels = np.arange(1, num_label + 1)
slope_label = ndimage.labeled_comprehension(slope, Lab_wet, labels, np.sum, float, 0)
slope_sign_label = ndimage.labeled_comprehension(slope_sign, Lab_wet, labels, np.sum, float, 0)
count_2 = ndimage.labeled_comprehension(bound_2, Lab_wet, labels, np.sum, float, 0)
water_ele_label = ndimage.labeled_comprehension(ele, Lab_wet, labels, np.min, float, 0)
slope_seg = np.zeros_like(org_wet).astype(np.float32)
slope_seg = slope_label[Lab_wet - 1].astype(np.float32) / count_2[Lab_wet - 1].astype(np.float32)
slope_seg = np.where((Lab_wet == 0) | (org_wet == 0), 0, slope_seg)
new_wet = np.where((slope_seg > min_slope) & (slope_seg < max_slope), 1, 0).astype(np.uint8)
width = arcpy.RasterToNumPyArray(width_raster, nodata_to_value=0)
depth = slope_seg * width / 2
del slope_seg, slope_label, width
slope_sign_seg = np.zeros_like(org_wet).astype(np.float32)
slope_sign_seg = slope_sign_label[Lab_wet - 1].astype(np.float32) / count_2[Lab_wet - 1].astype(np.float32)
slope_sign_seg = np.where((Lab_wet == 0) | (org_wet == 0), 0, slope_sign_seg)
new_wet = np.where((slope_sign_seg <= min_pos_slope), 0, new_wet).astype(np.uint8)
del slope_sign_seg, slope_sign_label, count_2
arcpy.NumPyArrayToRaster(new_wet, corner, dx, dx, value_to_nodata=0).save(wet_pos_depth_raster)
water_ele = water_ele_label[Lab_wet - 1].astype(np.float32) + depth
water_ele = np.where((Lab_wet == 0) | (new_wet == 0), 0, water_ele)
arcpy.NumPyArrayToRaster(water_ele, corner, dx, dx, value_to_nodata=0).save(water_ele_raster)
del new_wet, water_ele, depth
def allocate(self,random_effect = 0.5,error_num = 10,max_interation = 100):
nodataValue = arcpy.Raster(self.land_map).noDataValue
x0 = float(arcpy.GetRasterProperties_management(self.land_map,'LEFT').getOutput(0))
y0 = float(arcpy.GetRasterProperties_management(self.land_map,'BOTTOM').getOutput(0))
size_land = float(arcpy.GetRasterProperties_management(self.land_map,'CELLSIZEX').getOutput(0))
land_array = arcpy.RasterToNumPyArray(self.land_map)
land_index = list(np.unique(land_array))
try:
land_index.remove(nodataValue)
except:
None
## print land_index
## add prt_zone to probabilities
for i in range(len(land_index)):
try:
self.probabilities[i] = arcpy.sa.Con(self.prt_zone,arcpy.sa.Con(arcpy.sa.EqualTo(self.land_map,land_index[i]),1,0),self.probabilities[i])
except:
None
##
or_area = []
for a in range(len(land_index)):
area = np.sum(land_array==land_index[a])
or_area.append(area)
self.matrix[a] = self.matrix[a]*area
print self.matrix
arcpy.AddMessage('allocate matrix:')
arcpy.AddMessage(self.matrix)
## print or_area,self.matrix
probability_array = [arcpy.RasterToNumPyArray(x) for x in self.probabilities]
### add random factor
for pp in probability_array:
for i in range(len(pp)):
for j in range(len(pp[i])):
pp[i,j] = (pp[i,j]+random_effect*random.random())/(1+random_effect)
## start processing
out_array = np.int8(np.zeros((len(land_array),len(land_array[0]))))
## print trans_area,or_area,trans_array
## iteration for every categories
for i in range(len(land_index)):
land_index1 = [x for x in land_index]
land_index1.remove(land_index[i])
land_index1 = [land_index[i]]+land_index1
for j in range(len(land_index1)-1):
print i,j,self.matrix[i,j]
list_error,list_break = [],[]
break_value = 0.5
interation_num = 1
while True:
list_break.append(break_value)
num = np.sum(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>break_value)))
error = (num-self.matrix[i,j])
list_error.append(error)
if interation_num > max_interation:
plt.plot(list_error,label = 'iteration error')
plt.plot(list_break,label = 'break_value')
plt.legend()
plt.title('allocation {0} to {1}, error ={2}'.format(land_index[i],land_index1[j],error))
print "unsuccesfully allocate category {0} to {1} with error_rate of {2}, pleast close the figure to continue".format(land_index[i],land_index1[j],error)
out_array = out_array+(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>break_value))*land_index[j])
plt.savefig(os.path.join(self.path,str(land_index[i])+'to'+str(land_index1[j])))
plt.close()
break
try:
if error > error_num:
interation_num += 1
print break_value,num,self.matrix[i,j]
break_value += 1.0/(2**interation_num)
elif error < (-error_num):
interation_num += 1
print break_value,num,self.matrix[i,j]
break_value -= 1.0/(2**interation_num)
else:
plt.plot(list_error,label = 'iteration error')
plt.plot(list_break,label = 'break_value')
plt.legend()
plt.title('allocation {0} to {1}, error ={2}'.format(land_index[i],land_index1[j],error))
print "succesfully allocate category {0} to {1} with error_rate of {2}, pleast close the figure to continue".format(land_index[i],land_index1[j],error)
plt.savefig(os.path.join(self.path,str(land_index[i])+'to'+str(land_index1[j])))
out_array = out_array+(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>break_value))*land_index[j])
plt.close()
break
except:
plt.plot(list_error,label = 'iteration error')
plt.plot(list_break,label = 'break_value')
plt.legend()
plt.title('allocation {0} to {1}, error ={2}'.format(land_index[i],land_index1[j],error))
print "unsuccesfully allocate category {0} to {1} with error_rate of {2}, pleast close the figure to continue".format(land_index[i],land_index1[j],error)
out_array = out_array+(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>break_value))*land_index[j])
plt.savefig(os.path.join(self.path,str(land_index[i])+'to'+str(land_index1[j])))
plt.close()
break
j += 1
num = np.sum(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>0)))
error = (num-self.matrix[i,j])/np.sum(self.matrix[i])
print "succesfully allocate category {0} to {1} with error_rate of {2}".format(land_index[i],land_index1[j],error)
out_array = out_array+(((land_array==land_index[i])*(out_array==0)*(probability_array[j]>0))*land_index[j])
out_raster = arcpy.NumPyArrayToRaster(out_array,arcpy.Point(x0,y0),size_land,size_land,nodataValue)
out_raster.save(self.simulate_map)
arcpy.DefineProjection_management(self.simulate_map,self.land_map)
del probability_array[:]
return self.simulate_map
print 'done creating an array of the shapefiles'
print 'converting to rasters'
rasters=[]
for x in range(len(shapefiles)):
print 'converting',shapefiles[x]
raster=arcpy.PolygonToRaster_conversion(shapefiles[x], 'value', 'storm'+str(stormfolder)+'/raster'+str(x), 'CELL_CENTER', 'NONE',0.00012196015)
rasters.append(raster)
print 'completed raster conversion'
print 'calculating cell statistics'
maxreflect=CellStatistics (rasters, 'MAXIMUM', 'DATA')
maxreflect.save('storm'+str(stormfolder)+'/reflect'+str(stormfolder)+'.tif')
lowerLeft = arcpy.Point(maxreflect.extent.XMin,maxreflect.extent.YMin)
cellSize = maxreflect.meanCellWidth
reflectence=arcpy.RasterToNumPyArray(maxreflect)
rows=len(reflectence)
cols=len(reflectence[0])
rainfallraster=numpy.zeros((rows,cols))
for row in range(rows):
for col in range(cols):
if reflectence[row][col]<0:
rainfallraster[row][col]=0
rainfallraster[row][col]=(reflectence[row][col]/300)**(1/1.4)
where_are_NaNs = numpy.isnan(rainfallraster)
rainfallraster[where_are_NaNs]=0
newraster=arcpy.NumPyArrayToRaster(rainfallraster,lowerLeft,cellSize)
newraster.save('storm'+str(stormfolder)+'/rainfall'+str(stormfolder)+'.tif')
stormfolder=stormfolder+1
print 'completed rainfall calc'
print 'complete with folder',stormfolder
print 'finished making max reflectance rasters'
def tail():
tupDateNow = datetime.now()
while(1):
# buka file csv untuk mengetahui scene yang telah selesai diproses
#arcpy.env.workspace = config.gdbPath
log = pd.read_csv("logComplete.csv")
liScene = log["scene"].tolist()
liDate = log["dateComplete"].tolist()
msg = str(datetime.now()) + '\t' + "Importing Library ... \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
arcpy.CheckOutExtension("spatial")
# pass list yang telah selesai ke ftp download
filenameNow, scene, boolScene, year, month = ft.downloadFile(liScene)
del log
del liScene
del liDate
if(boolScene == False):
print "Data hari ini selesai diproses"
tupDateLoop = datetime.now()
while (tupDateNow.day == tupDateLoop.day):
print "menunggu hari berganti :)"
time.sleep(10)
tupDateLoop = datetime.now()
tupDateNow = tupDateLoop
print "hari telah berganti"
#definisikan nama file yang akan diproses
filename = filenameNow
# definisikan nama file keluaran hasil klasifikasi yang masih mentah
filenameOut = filenameNow + "_classified.TIF"
# definisikan letak file ers yang telah didownload dalam workstation
dataPath = config.dataPath + scene + "/" + filename
# definisikan letak model .pkl hasil training data sampel
modelPath = config.modelPath
# definisikan shp file indonesia untuk cropping batas administrasi
shpPath = config.shpPath
# definisikan folder keluaran hasil proses
outFolder = config.outputPath + filename.split(".")[0]
# jika folder ada maka hapus
if(os.path.exists(outFolder)):
shutil.rmtree(outFolder)
# buat folder yang telah didefinisikan
os.makedirs(outFolder)
# definisikan path file keluaran
outputPath = outFolder + "/" + filenameOut
##################### KONVERSI DATA ERS KE TIAP BAND ######################################
print ("converting b3")
if(os.path.exists(dataPath + "TOA_B3" + ".TIF")):
os.remove(dataPath + "TOA_B3" + ".TIF")
# Ambil hanya band 3 dan jadikan raster
try:
b_green = arcpy.Raster( dataPath + "/B3" ) * 1.0
except :
b_green = arcpy.Raster( dataPath + "/Band_3" ) * 1.0
print ("saving b3")
msg = str(datetime.now()) + '\t' + "saving b3 \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# save raster band 3 ke folder data input
b_green.save(dataPath + "TOA_B3" + ".TIF" )
del b_green
print ("converting b5")
if(os.path.exists(dataPath + "TOA_B5" + ".TIF")):
os.remove(dataPath + "TOA_B5" + ".TIF")
# Ambil hanya band 5 dan jadikan raster
try:
b_nir = arcpy.Raster( dataPath + "/B5" ) * 1.0
except:
b_nir = arcpy.Raster( dataPath + "/Band_5" ) * 1.0
print ("saving b5")
msg = str(datetime.now()) + '\t' + "saving b5 \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# save raster band 5 ke folder data input
b_nir.save( dataPath + "TOA_B5" + ".TIF" )
del b_nir
print ("converting b6")
if(os.path.exists(dataPath + "TOA_B6" + ".TIF")):
os.remove(dataPath + "TOA_B6" + ".TIF")
# Ambil hanya band 6 dan jadikan raster
try:
b_swir1 = arcpy.Raster( dataPath + "/B6") * 1.0
except:
b_swir1 = arcpy.Raster( dataPath + "/Band_6") * 1.0
msg = str(datetime.now()) + '\t' + "saving b6 \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
print ("saving b6")
# save raster band 6 ke folder data input
b_swir1.save( dataPath + "TOA_B6" + ".TIF" )
del b_swir1
####################### SELESAI KONVERSI DATA #######################################
#################### UBAH RASTER KE FORMAT DATAFRAME ###############################
msg = str(datetime.now()) + '\t' + "Processing file "+filename+"\n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# load semua raster yang telah dikonversi diawal
rasterarrayband6 = arcpy.RasterToNumPyArray(dataPath + "TOA_B3.TIF")
rasterarrayband6 = np.array(rasterarrayband6, dtype=np.uint32)
rasterarrayband5 = arcpy.RasterToNumPyArray(dataPath + "TOA_B5.TIF")
rasterarrayband5 = np.array(rasterarrayband5, dtype=np.uint32)
rasterarrayband3 = arcpy.RasterToNumPyArray(dataPath + "TOA_B6.TIF")
rasterarrayband3 = np.array(rasterarrayband3, dtype=np.uint32)
print rasterarrayband6.dtype
print("Change raster format to numpy array")
# gabungkan 3 array data secara horizontal
data = np.array([rasterarrayband6.ravel(), rasterarrayband5.ravel(), rasterarrayband3.ravel()], dtype=np.int16)
# ubah menjadi vertikal untuk kebutuhan prediksi .pkl
data = data.transpose()
# langsung hapus variabel yang tidak digunakan lagi
del rasterarrayband6
del rasterarrayband5
del rasterarrayband3
print("Change to dataframe format")
msg = str(datetime.now()) + '\t' + "Change to dataframe format \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
#time.sleep(1)
# definisikan nama kolom dataframe
columns = ['band3','band5', 'band6']
# ubah array vertical menjadi dataframe
df = pd.DataFrame(data, columns=columns)
# hapus array vertikal
del data
###################### SELESAI ####################################################
print("Split data to 20 chunks ")
msg = str(datetime.now()) + '\t' + "Split data to 20 chunks \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
#time.sleep(1)
# bagi data menjadi 20 bagian karena program tidak kuat prediksi sekaligus
df_arr = np.array_split(df, 20)
# hapus dataframe
del df
# load classifier (model pkl) yang telah di train
clf = joblib.load(modelPath)
# definisikan array untuk menampung nilai integer hasil prediksi
kelasAll = []
# ulangi untuk setiap bagian data
for i in range(len(df_arr)):
print ("predicting data chunk-%s\n" % i)
msg = str(datetime.now()) + '\t' + "predicting data chunk-%s\n" % i
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
msg2 = i
redis.rpush(config.MESSAGES_KEY_2, msg2)
redis.publish(config.CHANNEL_NAME_2, msg2)
#time.sleep(1)
# fungi untuk prediksi data baru dengan data ke i
kelas = clf.predict(df_arr[i])
# buat dataframe kosong
dat = pd.DataFrame()
# masukkan hasil prediksi data ke i ke kolom kelas
dat['kel'] = kelas
print ("mapping to integer class")
msg = str(datetime.now()) + '\t' + "mapping to integer class \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
#time.sleep(1)
# definisikan dictionary untuk ubah string kelas ke integer kelas prediksi
mymap = {'awan':1, 'air':2, 'tanah':3, 'vegetasi':4}
# fungsi map dengan parameter dictionary
dat['kel'] = dat['kel'].map(mymap)
# ubah kolom dataframe ke array
band1Array = dat['kel'].values
# ubah array ke numpy array dengan tipe unsigned 8 untuk menghindari memory error
band1Array = np.array(band1Array, dtype = np.uint8)
print ("extend to list")
msg = str(datetime.now()) + '\t' + "extend to list \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
#time.sleep(1)
#kelasAllZeros[] = band1Array
# masukkan numpy aray ke list prediksi
kelasAll.extend(band1Array.tolist())
# mencoba cek array hasil prediksi
print(kelasAll[1:10])
# hapus semua variabel yang tidak digunakan lagi
del df_arr
del clf
del kelas
del dat
del band1Array
print ("change list to np array")
msg = str(datetime.now()) + '\t' + "change list to np array \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# ubah list prediksi ke numpy array
kelasAllArray = np.array(kelasAll, dtype=np.uint8)
# hapus list prediksi
del kelasAll
print ("reshaping np array")
msg = str(datetime.now()) + '\t' + "reshaping np array \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
rasterarrayband6 = arcpy.RasterToNumPyArray(dataPath + "TOA_B3.TIF")
# reshape numpy array 1 dimensi ke dua dimensi sesuai format raster
band1 = np.reshape(kelasAllArray, (-1, rasterarrayband6[0].size))
# ubah tipe data ke unsigned integer
band1 = band1.astype(np.uint8)
del rasterarrayband6
# load raster band6 untuk kebutuhan projeksi dan batas batas raster
raster = arcpy.Raster(dataPath + "TOA_B6.TIF")
inputRaster = dataPath + "TOA_B6.TIF"
# ambil referensi spatial
spatialref = arcpy.Describe(inputRaster).spatialReference
# ambil tinggi dan lebar raster
cellsize1 = raster.meanCellHeight
cellsize2 = raster.meanCellWidth
# definisikan extent dari raster dan point dari extent
extent = arcpy.Describe(inputRaster).Extent
pnt = arcpy.Point(extent.XMin,extent.YMin)
# hapus yang tidak dipakai lagi
del raster
del kelasAllArray
# save the raster
print ("numpy array to raster ..")
msg = str(datetime.now()) + '\t' + "numpy array to raster .. \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# ubah numpy array ke raster dengan atribut yang telah didefinisikan
out_ras = arcpy.NumPyArrayToRaster(band1, pnt, cellsize1, cellsize2)
arcpy.CheckOutExtension("Spatial")
print ("define projection ..")
msg = str(datetime.now()) + '\t' + "define projection ..\n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
# simpan raster hasil konversi ke path yang telah didefinisikan
arcpy.CopyRaster_management(out_ras, outputPath)
# definisikan projeksi dengan referensi spatial
arcpy.DefineProjection_management(outputPath, spatialref)
print ("Majority Filter..")
msg = str(datetime.now()) + '\t' + "majority filter..\n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
#overwriteoutputPath outputPath enable
arcpy.env.workspace = config.outputPath
arcpy.env.overwriteOutput = True
#majority filter
arcpy.CheckOutExtension("Spatial")
outMajFilt = MajorityFilter(outputPath, "FOUR", "MAJORITY")
#Save the output
outMajFilt.save(outputPath)
# hapus yang tidak digunakan lagi
del out_ras
del band1
del spatialref
del cellsize1
del cellsize2
del extent
del pnt
########################### MASKING CLOUD AND BORDER #########################
print("Masking Cloud")
# load file cm hasil download yang disediakan
mask = Raster(os.path.dirname(dataPath) + "/" + filename.split(".")[0] + "_cm.ers")
# load raster hasil klasifikasi mentah
inRas = Raster(outputPath)
# jika file cm bernilai 1 = cloud, 2 = shadow, 11 = border
# ubah nilai tersebut menjadi 1 dan lainnya menjadi 0
#inRas_mask = Con((mask == 1), 1, Con((mask == 2), 1, Con((mask == 11), 1, 0)))
inRas_mask = Con((mask == 1), 1, Con((mask == 2), 1, Con((mask == 11), 1, Con((mask == 3), 1, Con((mask == 4), 1, Con((mask == 5), 1, Con((mask == 6), 1, Con((mask == 7), 1, 0))))))))
# buat raster yang merupakan nilai no data dari hasil kondisi diatas, hasilnya nodata = 1
# saya juga tidak mengerti yang bukan cloud jadi no data
mask2 = IsNull(inRas_mask)
# jika raster bernilai 1 maka ubah jadi 0, jika tidak tetap nilai raster hasil kondisi
inRas2 = Con((mask2 == 1), 0, inRas_mask)
# simpan raster pure dimana semua nilai 1 akan dihilangkan dari hasil klasifikasi
inRas2.save(os.path.dirname(outputPath) + "/" + filenameOut.split(".")[0] + "_mask.TIF")
# jika raster bernilai 1 maka jadi no data, jika tidak maka tetap si raster hasil awal
inRas_mask2 = SetNull(inRas2 == 1, inRas)
# simpan raster yang telah bersih dari cloud dan border yang jelek
inRas_mask2.save(os.path.dirname(outputPath) + "/" + filenameOut.split(".")[0] + "_maskCloud.TIF")
# hapus variabel conditional yang tidak digunakan lagi
del mask
del mask2
del inRas
del inRas2
del inRas_mask
del inRas_mask2
############################## SELESAI ###########################################
####################### MASKING DENGAN SHP INDONESIA ##############################
print("Masking with shp indonesia")
arcpy.CheckOutExtension("Spatial")
# buka file shp indonesia
inMaskData = os.path.join(shpPath, "INDONESIA_PROP.shp")
# buka raster hasil masking cloud dan border
inRasData = Raster(os.path.dirname(outputPath) + "/" + filenameOut.split(".")[0] + "_maskCloud.TIF")
# terapkan fungsi masking dengan shapefile
try:
outExtractByMask = ExtractByMask(inRasData, inMaskData)
print("Saving in: " + str(os.path.dirname(outputPath) + "/" + filenameOut.split(".")[0] + "_maskShp.TIF"))
# simpan hasil masking
outExtractByMask.save(os.path.dirname(outputPath) + "/" + filenameOut.split(".")[0] + "_maskShp.TIF")
finalPath = config.finalOutputPath + year + "/" + month + "/" + filenameNow.split(".")[0]
print finalPath
if( os.path.exists(finalPath) ):
shutil.rmtree(finalPath)
os.makedirs(finalPath)
arcpy.CopyRaster_management( outExtractByMask, finalPath + "/" + filenameOut)
# hapus lagi dan lagi variabel yang tidak digunakan
del inMaskData
del inRasData
del outExtractByMask
except:
print "diluar indonesia shp"
finalPath = config.finalOutputPath + year + "/" + month + "/" + filenameNow.split(".")[0]
print finalPath
if( os.path.exists(finalPath) ):
shutil.rmtree(finalPath)
os.makedirs(finalPath)
arcpy.CopyRaster_management( inRasData, finalPath + "/" + filenameOut)
pass
########################## SELESAI ################################################
####################### SAVE LOG DATA YANG TELAH SELESAI DIPROSES ########################################
log = pd.read_csv("logComplete.csv")
liScene = log["scene"].tolist()
liDate = log["dateComplete"].tolist()
liScene.append(scene)
liDate.append(str(datetime.now()))
print(liScene)
print(liDate)
serScene = pd.Series(liScene)
serDate = pd.Series(liDate)
print(serScene)
print(serDate)
log2 = pd.DataFrame()
log2["scene"] = serScene
log2["dateComplete"] = serDate
print(log2.head(5))
log2.to_csv("logComplete.csv", index=False)
del liScene
del liDate
del serScene
del serDate
del log
del log2
##########################################################################################################
# delete downloaded data in workstation
dataFolder = os.listdir(config.dataPath)
print dataFolder
if(len(dataFolder) > 1):
print config.dataPath + dataFolder[0]
shutil.rmtree(config.dataPath + dataFolder[0])
hasilFolder = os.listdir(config.outputPath)
print hasilFolder
if(len(hasilFolder) > 1):
print config.outputPath + hasilFolder[0]
shutil.rmtree(config.outputPath + hasilFolder[0])
print ("Finished ..")
msg = str(datetime.now()) + '\t' + "Finished ... \n"
redis.rpush(config.MESSAGES_KEY, msg)
redis.publish(config.CHANNEL_NAME, msg)
redis.delete(config.MESSAGES_KEY)
redis.delete(config.MESSAGES_KEY_2)
# local variable to list
dictLocal = locals()
# delete all local variable, hope will free some space
for key in dictLocal.keys():
del key
clear_all()
# bersih bersih lainnya
gc.collect()
#shutil.rmtree(config.gdbPath)
arcpy.Delete_management(config.gdbPathDefault)
arcpy.Delete_management("in_memory")
arcpy.env.overwriteOutput = True
def from_numpy(numpy_rast, metadata, outpath, NoData_Value=None):
"""
Wrapper for arcpy.NumPyArrayToRaster function with better metadata handling
this is just a wrapper for the NumPyArrayToRaster function within arcpy. It is used in
conjunction with to_numpy to streamline reading image files in and out of numpy
arrays. It also ensures that all spatial referencing and projection info is preserved
between input and outputs of numpy manipulations.
:param numpy_rast: The numpy array version of the input raster
:param metadata: The variable exactly as output from "to_numpy"
:param outpath: Output filepath of the individual raster
:param NoData_Value: The no data value of the output raster
:return outpath: Same as input outpath, filepath to created file.
Usage example
call to_numpy with "rast,metadata = to_numpy(Raster)"
perform numpy manipulations as you please
then save the array with "raster.from_numpy(rast, metadata, output)"
"""
numpy_rast = numpy_rast.astype(metadata.numpy_datatype)
if NoData_Value is None:
NoData_Value = metadata.NoData_Value
llcorner = arcpy.Point(metadata.Xmin, metadata.Ymin)
# save the output.
if isinstance(numpy_rast, numpy.ma.core.MaskedArray):
mask = numpy_rast.mask
data = numpy_rast.data
data[mask] = metadata.NoData_Value
OUT = arcpy.NumPyArrayToRaster(data, llcorner, metadata.cellWidth,
metadata.cellHeight)
OUT.save(outpath)
elif isinstance(numpy_rast, numpy.ndarray):
OUT = arcpy.NumPyArrayToRaster(numpy_rast, llcorner,
metadata.cellWidth, metadata.cellHeight)
OUT.save(outpath)
# define its projection
try:
arcpy.DefineProjection_management(outpath, metadata.projection)
except:
Warning("Unable to define the projection on {0}".format(outpath))
# reset the NoData_Values
try:
arcpy.SetRasterProperties_management(outpath,
data_type="#",
statistics="#",
stats_file="#",
nodata="1 " + str(NoData_Value))
except:
Warning("Unable to establish NoData profile on {0}".format(outpath))
# calculate statistics and pyramids
arcpy.CalculateStatistics_management(outpath)
arcpy.BuildPyramids_management(outpath)
print("Saved output file as {0}".format(outpath))
return outpath
def run_year(self):
logging.info('starting garden disturbance for year: %s' % self.year)
logging.info('garden {} is using ecocom: {} {}'.format(
self.year, self.ecocommunities, type(self.ecocommunities)))
self.calculate_suitability()
self.points_to_coordinates()
self.set_populations()
logging.info('checking for existing gardens')
for population, coordinates in zip(self.site_populations,
self.coordinate_list):
logging.info('garden coordinates: {} {}'.format(
coordinates[0], coordinates[1]))
self.site_center = arcpy.Point(coordinates[0], coordinates[1])
self.population = population
self.population_to_garden_area()
self.set_local_extent()
# check for gardens in area buffered around site (from set_local_extent)
# if garden area of garden is 0 create new garden
if self.garden_area == 0:
arcpy.env.extent = self.temp_buffer
self.set_garden_center()
# Continue only if garden center has been assigned
if self.garden is not None:
self.create_garden()
arcpy.env.extent = self.ecocommunities
# Return garden cells from self.garden else return existing communities
self.ecocommunities = arcpy.sa.Con(
arcpy.sa.IsNull(self.garden) == 0, self.garden,
self.ecocommunities)
thisisabsurd = random.randint(0, 1000000)
fn = 'ecocommunities_{}_{}.tif'.format(
self.year, thisisabsurd)
self.ecocommunities.save((os.path.join(s.TEMP_DIR, fn)))
logging.info('ecocommunities: {}'.format(
self.ecocommunities))
e = arcpy.RasterToNumPyArray(self.ecocommunities)
self.canopy[e == s.GARDEN_ID] = 0
self.forest_age[e == s.GARDEN_ID] = 0
self.dbh[e == s.GARDEN_ID] = 0
# self.dbh[(e == s.SUCCESSIONAL_OLD_FIELD_ID) & (self.forest_age == 0)] = 0.5
arcpy.env.extent = self.ecocommunities
self.ecocommunities.save(
(os.path.join(s.OUTPUT_DIR, 'ecocommunities_%s.tif' % self.year)))
logging.info('ecocom after garden disturbance: {}'.format(
self.ecocommunities))
self.time_since_disturbance = arcpy.sa.Con(
self.ecocommunities == s.GARDEN_ID, 0,
self.time_since_disturbance + 1)
self.time_since_disturbance.save(
os.path.join(self.OUTPUT_DIR,
'time_since_disturbance_%s.tif' % self.year))
canopy = arcpy.NumPyArrayToRaster(self.canopy,
arcpy.Point(arcpy.env.extent.XMin,
arcpy.env.extent.YMin),
x_cell_size=s.CELL_SIZE,
y_cell_size=s.CELL_SIZE)
canopy.save(s.CANOPY)
forestage = arcpy.NumPyArrayToRaster(self.forest_age,
arcpy.Point(
arcpy.env.extent.XMin,
arcpy.env.extent.YMin),
x_cell_size=s.CELL_SIZE,
y_cell_size=s.CELL_SIZE)
forestage.save(s.FOREST_AGE)
dbh = arcpy.NumPyArrayToRaster(self.dbh,
arcpy.Point(arcpy.env.extent.XMin,
arcpy.env.extent.YMin),
x_cell_size=s.CELL_SIZE,
y_cell_size=s.CELL_SIZE)
dbh.save(s.DBH)
logging.info('garden area: %s' % self.garden_area)
self.ecocommunities = None
del self.ecocommunities
def execute(self, parameters, messages):
"""The source code of the tool."""
arcpy.env.overwriteOutput = True
scratchWorkspace = arcpy.env.scratchWorkspace
if not scratchWorkspace:
scratchWorkspace = arcpy.env.scratchGDB
in_nc = parameters[0].valueAsText
in_rapid_connect_file = parameters[1].valueAsText
in_catchment = parameters[2].valueAsText
streamID = parameters[3].valueAsText
out_WeightTable = parameters[4].valueAsText
out_CGPolygon = parameters[5].valueAsText
out_CGPoint = parameters[6].valueAsText
# validate the netcdf dataset
self.dataValidation(in_nc, messages)
# open netcdf dataset
data_nc = NET.Dataset(in_nc)
'''Obtain west-east, south-north dimension information'''
name_xdim = 'west_east'
name_ydim = 'south_north'
size_xdim = len(data_nc.dimensions['west_east'])
size_ydim = len(data_nc.dimensions['south_north'])
#####################Start of script adaption###############################################################
'''Obtain projection information'''
map_proj = data_nc.__dict__['MAP_PROJ']
# read projection information from global attributes
corner_lats = data_nc.__dict__['corner_lats']
corner_lons = data_nc.__dict__['corner_lons']
DX = data_nc.__dict__['DX']
DY = data_nc.__dict__['DY']
standard_parallel_1 = data_nc.__dict__['TRUELAT1']
standard_parallel_2 = data_nc.__dict__['TRUELAT2']
central_meridian = data_nc.__dict__['STAND_LON']
pole_latitude = data_nc.__dict__['POLE_LAT']
pole_longitude = data_nc.__dict__['POLE_LON']
latitude_of_origin = data_nc.__dict__['CEN_LAT']
# Create Projection file with information from NetCDF global attributes
sr2 = arcpy.SpatialReference()
if map_proj == 1:
# Lambert Conformal Conic
if 'standard_parallel_2' in locals():
arcpy.AddMessage(
' Using Standard Parallel 2 in Lambert Conformal Conic map projection.'
)
else:
# According to http://webhelp.esri.com/arcgisdesktop/9.2/index.cfm?TopicName=Lambert_Conformal_Conic
standard_parallel_2 = standard_parallel_1
latitude_of_origin = standard_parallel_1
Projection_String = (
'PROJCS["North_America_Lambert_Conformal_Conic",'
'GEOGCS["GCS_Sphere",'
'DATUM["D_Sphere",SPHEROID["Sphere",6370000.0,0.0]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Lambert_Conformal_Conic"],'
'PARAMETER["false_easting",0.0],'
'PARAMETER["false_northing",0.0],'
'PARAMETER["central_meridian",' + str(central_meridian) + '],'
'PARAMETER["standard_parallel_1",' + str(standard_parallel_1) +
'],'
'PARAMETER["standard_parallel_2",' + str(standard_parallel_2) +
'],'
'PARAMETER["latitude_of_origin",' + str(latitude_of_origin) +
'],'
'UNIT["Meter",1.0]]')
elif map_proj == 2:
# Polar Stereographic
# Set up pole latitude
phi1 = float(standard_parallel_1)
### Back out the central_scale_factor (minimum scale factor?) using formula below using Snyder 1987 p.157 (USGS Paper 1395)
##phi = math.copysign(float(pole_latitude), float(latitude_of_origin)) # Get the sign right for the pole using sign of CEN_LAT (latitude_of_origin)
##central_scale_factor = (1 + (math.sin(math.radians(phi1))*math.sin(math.radians(phi))) + (math.cos(math.radians(float(phi1)))*math.cos(math.radians(phi))))/2
# Method where central scale factor is k0, Derivation from C. Rollins 2011, equation 1: http://earth-info.nga.mil/GandG/coordsys/polar_stereographic/Polar_Stereo_phi1_from_k0_memo.pdf
# Using Rollins 2011 to perform central scale factor calculations. For a sphere, the equation collapses to be much more compact (e=0, k90=1)
central_scale_factor = (
1 + math.sin(math.radians(abs(phi1)))
) / 2 # Equation for k0, assumes k90 = 1, e=0. This is a sphere, so no flattening
loglines.append(' Central Scale Factor: %s' %
central_scale_factor)
arcpy.AddMessage(loglines[-1])
Projection_String = ('PROJCS["Sphere_Stereographic",'
'GEOGCS["GCS_Sphere",'
'DATUM["D_Sphere",'
'SPHEROID["Sphere",6370000.0,0.0]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Stereographic"],'
'PARAMETER["False_Easting",0.0],'
'PARAMETER["False_Northing",0.0],'
'PARAMETER["Central_Meridian",' +
str(central_meridian) + '],'
'PARAMETER["Scale_Factor",' +
str(central_scale_factor) + '],'
'PARAMETER["Latitude_Of_Origin",' +
str(standard_parallel_1) + '],'
'UNIT["Meter",1.0]]')
elif map_proj == 3:
# Mercator Projection
Projection_String = ('PROJCS["Sphere_Mercator",'
'GEOGCS["GCS_Sphere",'
'DATUM["D_Sphere",'
'SPHEROID["Sphere",6370000.0,0.0]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Mercator"],'
'PARAMETER["False_Easting",0.0],'
'PARAMETER["False_Northing",0.0],'
'PARAMETER["Central_Meridian",' +
str(central_meridian) + '],'
'PARAMETER["Standard_Parallel_1",' +
str(standard_parallel_1) + '],'
'UNIT["Meter",1.0],AUTHORITY["ESRI",53004]]')
elif map_proj == 6:
# Cylindrical Equidistant (or Rotated Pole)
# Check units (linear unit not used in this projection). GCS?
Projection_String = ('PROJCS["Sphere_Equidistant_Cylindrical",'
'GEOGCS["GCS_Sphere",'
'DATUM["D_Sphere",'
'SPHEROID["Sphere",6370000.0,0.0]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Equidistant_Cylindrical"],'
'PARAMETER["False_Easting",0.0],'
'PARAMETER["False_Northing",0.0],'
'PARAMETER["Central_Meridian",' +
str(central_meridian) + '],'
'PARAMETER["Standard_Parallel_1",' +
str(standard_parallel_1) + '],'
'UNIT["Meter",1.0],AUTHORITY["ESRI",53002]]')
sr2.loadFromString(Projection_String)
'''Create a projected ones raster'''
arr_ones = NUM.ones((size_ydim, size_xdim), dtype=NUM.uint16)
#####################Start of script adaption###############################################################
# Create a point geometry object from gathered corner point data
sr1 = arcpy.SpatialReference(104128) # Using EMEP Sphere (6370000m)
point = arcpy.Point()
point.X = float(corner_lons[0])
point.Y = float(corner_lats[0])
pointGeometry = arcpy.PointGeometry(point, sr1)
projpoint = pointGeometry.projectAs(sr2)
# Get projected X and Y of the point geometry and adjust so lower left corner becomes lower left center
point2 = arcpy.Point((projpoint.firstPoint.X - (float(DX) / 2)),
(projpoint.firstPoint.Y -
(float(DY) / 2))) # Adjust by half a grid cell
# Process: Numpy Array to Raster
ras_ones = arcpy.NumPyArrayToRaster(arr_ones, point2, float(DX),
float(DY))
# Process: Define Projection
arcpy.DefineProjection_management(ras_ones, sr2)
ras_ones.save(os.path.join(scratchWorkspace, "ras_ones"))
################End of script adaption######################################################################
'''Create CG Polygon for the buffered catchment'''
arcpy.AddMessage("Creating computation grid polygons...")
# Obtain a minimum bounding envelope of the catchment with the same spatial reference as the WRF-Hydro data
envelope = os.path.join(scratchWorkspace, "envelope")
arcpy.env.outputCoordinateSystem = sr2
result0 = arcpy.MinimumBoundingGeometry_management(
in_catchment, envelope, "ENVELOPE", "ALL")
arcpy.ResetEnvironments()
envelope = result0.getOutput(0)
# Determine whether the input catchment is within the WRF-Hydro data extent
ext_ras_ones = arcpy.Describe(ras_ones).extent
ext_envelope = arcpy.Describe(envelope).extent
if ext_envelope.XMin < ext_ras_ones.XMin \
or ext_envelope.XMax > ext_ras_ones.XMax \
or ext_envelope.YMin < ext_ras_ones.YMin \
or ext_envelope.YMax > ext_ras_ones.YMax:
# Input Catchments exceed the WRF data extent
messages.addErrorMessage(self.errorMessages[2])
raise arcpy.ExecuteError
# Buffer the minimum bounding envelope
envelope_b = os.path.join(scratchWorkspace, "envelope_b")
dist_buffer = str(int(DX) * 3) + " Meters"
result1 = arcpy.Buffer_analysis(envelope, envelope_b, dist_buffer,
"FULL", "#", "ALL")
envelope_b = result1.getOutput(0)
# Convert the buffered envelope into raster with cellsize, and snapraster the same as ras_ones
arcpy.env.snapRaster = ras_ones
arcpy.env.cellSize = ras_ones
name_OID = arcpy.Describe(envelope_b).OIDFieldName
ras_env_b = os.path.join(scratchWorkspace, "ras_env_b")
arcpy.PolygonToRaster_conversion(envelope_b, name_OID, ras_env_b,
'CELL_CENTER', 'NONE', ras_ones)
arcpy.ResetEnvironments()
# Create fishnet based on the clipped raster
# Get the extent of the raster
ext_ras = arcpy.Describe(ras_env_b).extent
xmin_ras = ext_ras.XMin
ymin_ras = ext_ras.YMin
# Set parameters of the output fishnet
originCoordinate = str(xmin_ras) + ' ' + str(ymin_ras) # the origin
yAxiCoordinate = str(xmin_ras) + ' ' + str(
ymin_ras + 10) # the orientation
cellSizeWidth = str(DX)
cellSizeHeight = str(DY)
ras_temp = arcpy.sa.Raster(ras_env_b)
numRows = str(ras_temp.height)
numCols = str(ras_temp.width)
labels = "NO_LABELS"
if out_CGPoint is not None:
labels = "LABELS"
oppositeCorner = ""
templateExtent = ras_env_b
geometryType = "POLYGON"
if out_CGPolygon is None:
out_CGPolygon = os.path.join(scratchWorkspace, "out_CGPolygon")
# Create fishnet (computation grid polygon) (and point if specified)
result2 = arcpy.CreateFishnet_management(
out_CGPolygon, originCoordinate, yAxiCoordinate, cellSizeWidth,
cellSizeHeight, numRows, numCols, oppositeCorner, labels,
templateExtent, geometryType)
out_CGPolygon = result2.getOutput(0)
# Add and calculate fields of CENTROID_X and CENTROD_Y for fishnet (computation grid polygon)
arcpy.AddGeometryAttributes_management(out_CGPolygon, "CENTROID", "#",
"#", "#")
temp_CGPoint = None
(dirnm_out_CGPolygon,
basenm_out_CGPolygon) = os.path.split(out_CGPolygon)
if not basenm_out_CGPolygon.endswith(".shp"):
temp_CGPoint = out_CGPolygon + "_label"
else:
temp_CGPoint = os.path.join(
dirnm_out_CGPolygon,
"{}_label.shp".format(basenm_out_CGPolygon[:-4]))
if arcpy.Exists(temp_CGPoint) and out_CGPoint is not None and (
temp_CGPoint) != out_CGPoint:
if not arcpy.Exists(out_CGPoint):
arcpy.CopyFeatures_management(temp_CGPoint, out_CGPoint)
arcpy.Delete_management(temp_CGPoint)
# Get latitude and longitude
lat_arr = data_nc.variables["XLAT_M"][:]
lon_arr = data_nc.variables["XLONG_M"][:]
data_nc.close()
'''Create weight table'''
# Obtain the minimum X and minimum Y for the lower left pixel center of the ones raster
minX = projpoint.firstPoint.X
minY = projpoint.firstPoint.Y
# Intersect the catchment polygons with the computation grid polygons
arcpy.AddMessage(
"Intersecting computation grid polygons with catchment...")
intersected = os.path.join(scratchWorkspace, "intersected")
result3 = arcpy.Intersect_analysis([out_CGPolygon, in_catchment],
intersected, "ALL", "#", "INPUT")
intersected = result3.getOutput(0)
# Calculate the geodesic area in square meters for each intersected polygon
arcpy.AddMessage("Calculating geodesic areas...")
arcpy.AddGeometryAttributes_management(intersected, "AREA_GEODESIC",
"", "SQUARE_METERS", "")
# Calculate the total geodesic area of each catchment based on the contributing areas of points
fields = [streamID, "CENTROID_X", "CENTROID_Y", "AREA_GEO"]
area_arr = arcpy.da.FeatureClassToNumPyArray(intersected, fields)
arcpy.AddMessage("Writing the weight table...")
# Get list of COMIDs in rapid connect file so only those area included in computations
connectivity_table = self.csvToList(in_rapid_connect_file)
streamID_unique_list = [int(row[0]) for row in connectivity_table]
# Get some dummy data from the first row
centroidX_dummy = area_arr["CENTROID_X"][0]
centroidY_dummy = area_arr["CENTROID_Y"][0]
indexX_dummy = long(round((centroidX_dummy - minX) / float(DX)))
indexY_dummy = long(round((centroidY_dummy - minY) / float(DY)))
lon_dummy = lon_arr[0, indexY_dummy, indexX_dummy]
lat_dummy = lat_arr[0, indexY_dummy, indexX_dummy]
with open(out_WeightTable, 'wb') as csvfile:
connectwriter = csv.writer(csvfile, dialect='excel')
#header
connectwriter.writerow([
streamID, "area_sqm", "west_east", "south_north", "npoints",
"weight", "Lon", "Lat", "x", "y"
])
for streamID_unique in streamID_unique_list:
ind_points = NUM.where(
area_arr[streamID] == streamID_unique)[0]
num_ind_points = len(ind_points)
# Get the total area
area_geo_total = 0
for ind_point in ind_points:
area_geo_total += float(area_arr["AREA_GEO"][ind_point])
if num_ind_points <= 0:
# if point not in array, append dummy data for one point of data
# streamID, "area_sqm", "west_east", "south_north", "npoints", "weight", "Lon", "Lat", "x", "y"
row_dummy = [
streamID_unique, 0, indexX_dummy, indexY_dummy, 1, 1.0,
lon_dummy, lat_dummy, centroidX_dummy, centroidY_dummy
]
connectwriter.writerow(row_dummy)
else:
for ind_point in ind_points:
area_geo_each = float(area_arr['AREA_GEO'][ind_point])
weight_each = area_geo_each / area_geo_total
centroidX = area_arr["CENTROID_X"][ind_point]
centroidY = area_arr["CENTROID_Y"][ind_point]
indexX = long(round((centroidX - minX) / float(DX)))
indexY = long(round((centroidY - minY) / float(DY)))
lon = lon_arr[0, indexY, indexX]
lat = lat_arr[0, indexY, indexX]
row = [
streamID_unique, area_geo_each, indexX, indexY,
num_ind_points, weight_each, lon, lat, centroidX,
centroidY
]
connectwriter.writerow(row)
return
sr= arcpy.GetParameterAsText(2)
#get lower left corner of first raster layer for projection later on
desc = arcpy.Describe(fr)
x = desc.extent.XMin
y = desc.extent.YMin
#convert first and second raster to numpy array
fr_array= arcpy.RasterToNumPyArray(fr)
sr_array= arcpy.RasterToNumPyArray(sr)
#get difference between second raster and first raster
diff_array=sr_array-fr_array
#convert the difference raster to array
diff_raster=arcpy.NumPyArrayToRaster(diff_array,arcpy.Point(x,y),'','',-9999)
final_ws= ws + '\\'
diff_raster.save(final_ws + 'diff_raster')
#get spatial reference of original first raster
coor_system = arcpy.Describe(fr).spatialReference
#project the difference raster to match the original raster
projected_raster=arcpy.management.ProjectRaster(diff_raster,final_ws+'projected_raster',coor_system,'','','','',coor_system)
#projected_raster.save(final_ws +'projected_raster')
#add differnece layer to map
p=arcpy.mp.ArcGISProject("CURRENT")
m=p.listMaps()[0]
#make a feature layer from feature class
inputdata = arcpy.RasterToNumPyArray(InputRaster)
OutputArray = np.memmap(TemporaryFile(), "uint8", "w+", shape=inputdata.shape)
descData = arcpy.Describe(InputRaster + "\\Band_1")
cellSize = descData.meanCellHeight
sr = descData.spatialReference
extent = descData.Extent
pnt = arcpy.Point(extent.XMin, extent.YMin)
rows = inputdata.shape[0]
cols = inputdata.shape[1]
for i in range(0, rows, blockSize):
if (i + blockSize) < rows:
numRows = blockSize
else:
numRows = rows - i
for j in range(0, cols, blockSize):
if (j + blockSize) < cols:
numCols = blockSize
else:
numCols = cols - j
OutputArray[i:i + numRows,
j:j + numCols] = vbitreader(inputdata[i:i + numRows,
j:j + numCols])
arcpy.AddMessage("row {0} of {1} column {2} of {3}".format(
(i / blockSize + 1), int(rows / blockSize + 1),
(j / blockSize + 1), int(cols / blockSize + 1)))
outraster = arcpy.NumPyArrayToRaster(OutputArray, pnt, cellSize, cellSize, 0)
outraster.save(OutputFolder + "\\" + OutputFileName)
def create_response_raster(classifier, rasters, output, scale):
"""
create_response_raster
Uses a classifier in a multiband raster to obtain the response raster
:param classifier: Classifier object previously trained
:param rasters: Multiband raster with the information to be put in the classifier
:param output: Name of the file for the response raster
:param scale: Object with the transformation to be done to normalize the data. If None, then no transformation
is made
:return: None
"""
# Obtain spatial information from the raster
spatial_reference = arcpy.Describe(rasters).spatialReference
raster = arcpy.Raster(rasters)
lower_left_corner = arcpy.Point(raster.extent.XMin, raster.extent.YMin)
x_cell_size = raster.meanCellWidth
y_cell_size = raster.meanCellHeight
# Import the multiband raster to numpy array if the raster is of type integer it will throw an error because of the
# NaN values, then is imported wit NaNs as maximum integers, casted to float and then the NaNs applied
try:
raster_array = arcpy.RasterToNumPyArray(rasters,
nodata_to_value=np.NaN)
except ValueError:
_verbose_print("Integer type raster, changed to float")
raster_array = 1.0 * arcpy.RasterToNumPyArray(
rasters, nodata_to_value=sys.maxint)
raster_array[raster_array == sys.maxint] = np.NaN
MESSAGES.AddMessage("Creating response raster...")
# If it is a single band, then the raster must be reshaped as a tri-dimensional numpy array
if raster_array.ndim == 2:
raster_array = np.reshape(raster_array, [1] + list(raster_array.shape))
n_regr = raster_array.shape[0]
n_rows = raster_array.shape[1]
n_cols = raster_array.shape[2]
_verbose_print("{} regressors of shape {} x {}".format(
n_regr, n_rows, n_cols))
# The raster looping must be done in the last dimension
raster_array2 = np.empty([n_rows, n_cols, n_regr])
for raster_index in range(n_regr):
raster_array2[:, :, raster_index] = raster_array[raster_index, :, :]
# The matrix is reshaped from 3D to 2D
raster_array2 = np.reshape(raster_array2, [n_rows * n_cols, n_regr])
# Create a mask where the values of all regressors are finite. The calculations will be made just there
finite_mask = np.all(np.isfinite(raster_array2), axis=1)
nan_mask = np.logical_not(finite_mask)
_verbose_print("{} elements will be calculated and {} let as NaN".format(
sum(finite_mask), sum(nan_mask)))
# Make the transformation if available
if scale is None:
finite_array = raster_array2[finite_mask]
_verbose_print("Data not normalized")
else:
finite_array = scale.transform(raster_array2[finite_mask])
MESSAGES.AddMessage("Data normalized")
# Calculate decision_function for the elements with finite values. If not available use predict_proba
# TODO: Measure time
if getattr(classifier, "decision_function", None) is None:
_verbose_print(
"Decision function not available, probabilities used instead")
responses = classifier.predict_proba(
finite_array)[:, classifier.classes_ == 1]
else:
_verbose_print("Decision function used")
responses = classifier.decision_function(finite_array)
# Reshape the matrix with the response values
response_vector = np.empty(n_rows * n_cols)
response_vector[finite_mask] = responses
response_vector[nan_mask] = -9
response_array = np.reshape(response_vector, [n_rows, n_cols])
# Known bug: There is a minimal displacement between the input layers and the response
response_raster = arcpy.NumPyArrayToRaster(
response_array,
lower_left_corner=lower_left_corner,
x_cell_size=x_cell_size,
y_cell_size=y_cell_size,
value_to_nodata=-9)
response_raster.save(output)
# Known bug: if the output name is too long (the name not the path) then arcpy shows "unexpected error"
MESSAGES.AddMessage("Raster file created in " + output)
arcpy.DefineProjection_management(output, spatial_reference)
return
# Output = arcpy.getParameterAsText(2)
Flow_Direction = arcpy.Raster("flowdir.tif")
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: raise Exception("YMin of extents are not the same")
if BMP_Points.meanCellWidth != Flow_Direction.meanCellWidth: raise Exception("Cell sizes are not the same")
if len(bmppointData) != height:
print len(bmppointData[0]), height, width
raise Exception("Heights are not the same")
if len(bmppointData[0]) != width: raise Exception("Widths are not the same")
outputData = flowAccumulate(flowdirData)
# save outputs
outputRaster = arcpy.NumPyArrayToRaster(outputData,lowerLeft,cellSize)
outputRaster.save(Output)
def execute_task(in_extentDict):
fc_count = in_extentDict[0]
procExt = in_extentDict[1]
# print procExt
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
#The brilliant thing here is that using the extents with the full dataset!!!!!! DONT EVEN NEED TO CLIP THE FULL RASTER TO THE FISHNET BECASUE
arcpy.env.snapRaster = data['pre']['traj']['path']
arcpy.env.cellsize = data['pre']['traj']['path']
arcpy.env.outputCoordinateSystem = data['pre']['traj']['path']
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
cls = 21973
rws = 13789
# outData = numpy.zeros((rows,cols), numpy.int16)
outData = np.zeros((13789, 21973), dtype=np.int)
### create numpy arrays for input datasets cdls and traj
change = arcpy.RasterToNumPyArray(
in_raster=
'D:\\projects\\usxp\\series\\s14\\core\\core.gdb\\s14_traj_cdl30_b_2008to2016_rfnd_n8h_mtr_8w_mmu5',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973),
conf = arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\conf.gdb\\National_average_cdl_30m_r_2008to2016_albers_confidence',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=13789,
ncols=21973)
# np.nonzero(change)
# # arr_traj = arcpy.RasterToNumPyArray(in_raster=data['pre']['traj']['path'], lower_left_corner = arcpy.Point(XMin,YMin), nrows = 13789, ncols = 21973)
# # find the location of each pixel labeled with specific arbitray value in the rows list
# for row in location_list:
# #year of conversion for either expansion or abandonment
# ytx = row[1]
# print 'ytx', ytx
# #year before conversion for either expansion or abandonment
# ybx = row[1]-1
# print 'ybx', ybx
#Return the indices of the pixels that have values of the ytc arbitrsy values of the traj.
indices = np.nonzero(change)
print indices
# #stack indices so easier to work with
# stacked_indices=np.column_stack((indices[0],indices[1]))
# #get the x and y location of each pixel that has been selected from above
# for pixel_location in stacked_indices:
# row = pixel_location[0]
# col = pixel_location[1]
# print 'row', row
# print 'col', col
# #get the pixel value for ytx
# pixel_value_ytx = cdls[ytx][row][col]
# #get the pixel value for ybx
# pixel_value_ybx = cdls[ybx][row][col]
# print row
# ##### create dev mask componet
# # cdls
# if np.isnan(change[row,col]):
# print 'null'
# break
# else:
# outData[row,col] = conf[row,col]
# ##### create 36_61 mask componet
# if pixel_value_ytx in [36,61]:
# #find the years stil left in the time series for this pixel location
# yearsleft = [i for i in data['global']['years'] if i > ytx]
# #only focus on the extended series ---dont care about 2012
# if len(yearsleft) > 1:
# #create templist to hold the rest of the cld values for the time series. initiaite it with the first cdl value
# templist = [pixel_value_ytx]
# for year in yearsleft:
# # print 'year', year
# # print 'cdls[year][row][col] :', cdls[year][row][col]
# templist.append(cdls[year][row][col])
# #check if all elements in array are the same
# if len(set(templist)) == 1:
# outData[row,col] = data['refine']['mask_dev_alfalfa_fallow']['arbitrary']
arcpy.ClearEnvironment("extent")
outname = "tile_" + str(fc_count) + '.tif'
# #create
outpath = os.path.join("C:/Users/Bougie/Desktop/Gibbs/", r"tiles", outname)
# NumPyArrayToRaster (in_array, {lower_left_corner}, {x_cell_size}, {y_cell_size}, {value_to_nodata})
myRaster = arcpy.NumPyArrayToRaster(outData,
lower_left_corner=arcpy.Point(
XMin, YMin),
x_cell_size=30,
y_cell_size=30,
value_to_nodata=0)
myRaster.save(outpath)
n = 0
for l in range(lie - 2 * r):
print("The progress rate is %3f" % (float(l) / (lie - 2 * r)))
for h in range(hang - 2 * r):
n += 1
# print ("No. is "+ str(n))
dfg1clp = dfraster.iloc[h:h + 2 * r + 1, l:l + 2 * r + 1]
dfg2clp = dflower.iloc[h:h + 2 * r + 1, l:l + 2 * r + 1]
pig1=piWindow(dfg1clp)
pig2=piWindow(dfg2clp)
sumg1=0
nums=0
for g1,num in zip(g1class,numberlist):
nums+=num
sumg2=0
if pig1[g1]==0:
continue
elif num==1:
sumg1+=-pig1[g1]*math.log(pig1[g1])
else:
for g2 in g2class[nums-num:nums]:
if pig2[g2]!=0:
sumg2+=pig2[g2]*math.log(pig2[g2])
sumg1+=-pig1[g1]*math.log(pig1[g1])*(1-pig1[g1]*sumg2/math.log(num))
dfzero.iat[h + r, l + r] = sumg1
arrayzero = np.array(dfzero)
fusionRaster = arcpy.NumPyArrayToRaster(arrayzero, lowerLeft, cellSize)
arcpy.DefineProjection_management(fusionRaster, sourceSR)
fusionRaster.save(outpath)
print ("FLI-SHDI is ok")
# aggregate the image pixels within the new, larger pixel
for row in range(samplesize):
for col in range(samplesize):
# if the subpixel falls within the image:
if (0 <= pixpos[0] + col < cols) and (0 <= pixpos[1] + row < rows):
pixVal = image[pixpos[1]+row][pixpos[0]+col]
pixelNew[row][col] = pixVal
if pixVal == nodatavalue:
weights[row][col] = 0
else:
weights[row][col] = 0
# find out if the new pixel has a valid value:
weightSum = weights.sum()
if weightSum != 0:
weighted = weights * pixelNew
imageNew[rowNew][colNew] = weighted.sum() / weightSum
else:
imageNew[rowNew][colNew] = nodatavalue
# Convert Array to raster (keep the origin and cellsize the same as the input)
newRaster = arcpy.NumPyArrayToRaster(imageNew,lowerLeftNew,cellSizeSAT, value_to_nodata=nodatavalue)
arcpy.DefineProjection_management(newRaster, prjSAT)
newRaster.save(outMap)
print 'done'
arcpy.AddMessage('donzo')
def start_precipition(
self, river_catchment, DTM, region, precipitation_textfile,
baseflow_provided, day_pcp_yr, years_of_sim,
total_day_month_precip, total_avg_month_precip,
max_30min_rainfall_list, mannings_n, CULSE, orgC,
precipitation_gauge_elevation, CN2_d, GS_list, active_layer,
inactive_layer, active_layer_GS_P_temp, active_layer_V_temp,
inactive_layer_GS_P_temp, inactive_layer_V_temp,
numpy_array_location, output_file_dict, output_format,
output_excel_discharge, output_excel_sediment,
output_averages_temp, DTM_temp, slope_sub_path, slope_temp,
extent_xmin, extent_ymin, workspace):
# Check to see if the user wants to output discharge / sediment loss from the system
discharge_spamwriter, sediment_spamwriter = rasterstonumpys.save_discharge_or_sediment_csv(
output_excel_discharge, output_excel_sediment)
# Open the precipitation file
precipitation_read = open(precipitation_textfile)
### Set to default for the first loop ###
recalculate_slope_flow = True
##### Daily loop start #####
arcpy.AddMessage("Starting Model...")
for precipitation in precipitation_read:
# Ensure amount of availiable memory is at the optimum
collected = gc.collect()
arcpy.AddMessage("Garbage collector: collected %d objects." %
(collected))
start = time.time()
arcpy.AddMessage("Today's date is " + str(self.current_date))
self.day_of_year = int(self.current_date.strftime('%j'))
### CHECK TO SEE IF BASEFLOW NEEDS TO BE SEPERATED ###
precipitation, baseflow = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).check_baseflow(precipitation,
baseflow_provided)
### CHECK TO SEE IF THE SLOPE NEEDS TO BE CALCULATED ###
if recalculate_slope_flow == True and self.first_loop == False:
arcpy.AddMessage(
"Recalculating variables due to degree of elevation change"
)
DTM = arcpy.NumPyArrayToRaster(DTM, self.bottom_left_corner,
self.cell_size, self.cell_size,
-9999)
slope, DTM, flow_direction_np, flow_direction_raster, flow_accumulation, CN2s_d, CN1s_d, CN3s_d, ang = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).check_slope_flow_directions(
self.first_loop, self.use_dinfinity, self.day_of_year,
CN2_d, DTM, baseflow_provided, numpy_array_location)
if self.first_loop == True:
arcpy.AddMessage("Calculating variables for the first loop")
slope, DTM, flow_direction_np, flow_direction_raster, flow_accumulation, CN2s_d, CN1s_d, CN3s_d, ang = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).check_slope_flow_directions(
self.first_loop, self.use_dinfinity, self.day_of_year,
CN2_d, DTM, baseflow_provided, numpy_array_location)
DTM_MINUS_AL_IAL = elevation_adjustment.get_DTM_AL_IAL(
DTM, active_layer, inactive_layer, self.cell_size)
# change the inactive layer to m3
inactive_layer *= (self.cell_size * self.cell_size)
##### HYDROLOGY SECTION OF LOOP #####
# Calculate the daily precipitation in each grid cell
precipitation = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).spatial_uniform_spatial_precip(
precipitation, DTM, day_pcp_yr,
precipitation_gauge_elevation)
# Calculate the surface runoff in each grid cell (Not fatoring in antecedent conditions
Q_surf = hydrology.SCSCNQsurf(self.bottom_left_corner,
self.cell_size).OldQsurf(
precipitation, CN2s_d)
# Calculate the mean, max and min temperatures. The latitude and feed those into the evapotranspiration calculation ~~~~~~##### GOT HERE #####~~~~~~#
mean_temp, max_temp, min_temp = evapotranspiration.Evapotranspiration(
).MinMaxMeanTemp(region, self.current_date)
latitude = evapotranspiration.Evapotranspiration(
).UKlatituderadians(region, river_catchment)
ETo = evapotranspiration.Evapotranspiration(
).ReferenceEvapotranspiration(latitude, self.day_of_year, max_temp,
min_temp,
mean_temp) # need to define lat
# Check if this is the first loop of the models operation
if self.first_loop == True:
# Set a 0 value for Sprev
Sprev = np.zeros_like(DTM)
# Calculate the retention parameter (Antecedent Conditions and Evapotranspiration)
Scurr = hydrology.SCSCNQsurf(self.bottom_left_corner,
self.cell_size).RententionParameter(
precipitation, CN1s_d, CN2_d,
CN2s_d, ETo, Sprev, Q_surf,
self.first_loop)
# Calculate surface runoff and then convert to raster
Q_surf_np = hydrology.SCSCNQsurf(self.bottom_left_corner,
self.cell_size).SurfSCS(
precipitation, Scurr, CN2s_d)
Q_surf = arcpy.NumPyArrayToRaster(Q_surf_np,
self.bottom_left_corner,
self.cell_size, self.cell_size,
-9999)
# Execute Flow accumulation to work out the discharge.
Q_dis = ((Q_surf / 1000) / 86400) * (
self.cell_size * self.cell_size
) # convert to metres (by dividing by 1000) and then to seconds by dividing by 86400 and finally to the area of the cell by multiplying by the area of the cell.
if self.use_dinfinity == True:
Q_dis = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).FlowAccumulationDinf(
ang, Q_dis, numpy_array_location)
else:
Q_dis = FlowAccumulation(flow_direction_raster, Q_dis)
arcpy.AddMessage("Calculated discharge")
if baseflow_provided == True:
baseflow_raster = hydrology.SCSCNQsurf(
self.bottom_left_corner,
self.cell_size).BaseflowCalculation(
baseflow, flow_accumulation)
Q_dis += baseflow_raster
arcpy.Delete_management(baseflow_raster)
Q_dis = arcpy.RasterToNumPyArray(Q_dis, '#', '#', '#', -9999)
Q_max = np.amax(Q_dis)
arcpy.AddMessage("Discharge at the outlet for today is " +
str(Q_max))
arcpy.AddMessage(" ")
# If the user has selected to output the daily discharge value at the bottom of the catchment write that value to the excel
rasterstonumpys.output_discharge_csv(self.current_date,
discharge_spamwriter, Q_max)
# Scurr becomes Sprev
Sprev = Scurr
### HYDROLOGY GARBAGE COLLECTION ###
collected = gc.collect()
arcpy.AddMessage("Garbage collector: collected %d objects." %
(collected))
###SEDIMENT TRANSPORT SECTION OF LOOP###
if self.calculate_sediment_transport == True:
arcpy.AddMessage("Starting to calculate sediment transport...")
# Get the erosion values on the first loop
if self.first_loop == True:
self.depth_recking_threshold, self.discharge_erosion_threshold = sediment.sedimenttransport(
).get_erosion_threshold_values(self.cell_size)
sufficient_discharge_calculate_erosion = np.any(
Q_dis > self.discharge_erosion_threshold)
if sufficient_discharge_calculate_erosion == True:
arcpy.AddMessage(
"Sufficient Discharge for Erosion Calculation to Begin"
)
calculate_sediment_transport_based_on_depth = True
daily_save_date = str(
self.current_date.strftime('%d_%m_%Y'))
if calculate_sediment_transport_based_on_depth == True:
arcpy.AddMessage(
"Sufficient depth to calculate sediment transport")
# Calculate sediment transport for each timestep based on the above calculation
inactive_layer, DTM, DTM_MINUS_AL_IAL, recalculate_slope_flow, net_sediment, depth_recking = sediment.sedimenttransport(
).sediment_loop(
GS_list, Q_dis, slope, self.cell_size,
flow_direction_np, self.bottom_left_corner,
daily_save_date, active_layer_GS_P_temp,
active_layer_V_temp, inactive_layer_GS_P_temp,
inactive_layer_V_temp, inactive_layer, DTM,
DTM_MINUS_AL_IAL, self.depth_recking_threshold,
DTM_temp, slope_sub_path, slope_temp, extent_xmin,
extent_ymin, workspace)
sediment_depth = DTM - DTM_MINUS_AL_IAL
sediment_depth[Q_surf_np == -9999] = -9999
Sed_max = " "
elif calculate_sediment_transport_based_on_depth == False:
recalculate_slope_flow = False
sediment_depth = np.zeros_like(Q_surf_np)
net_sediment = np.zeros_like(Q_surf_np)
Sed_max = 0
sediment_depth[Q_surf_np == -9999] = -9999
net_sediment[Q_surf_np == -9999] = -9999
arcpy.AddMessage("-------------------------")
arcpy.AddMessage(
"Sediment transport will not be calculated for this timestep due to insufficient river depth"
)
arcpy.AddMessage("-------------------------")
# Check if the user would like to save sediment transport at the outlet
rasterstonumpys.output_sediment_csv(
self.current_date, sediment_spamwriter, Sed_max)
else:
recalculate_slope_flow = False
sediment_depth = 0
net_sediment = 0
depth_recking = 0
else:
recalculate_slope_flow = False
sediment_depth = 0
net_sediment = 0
depth_recking = 0
# Section of the loop to calculate peak runoff for the day
if self.calculate_sediment_erosion_hillslope == True:
calculate_sediment_erosion_hillslope_based_on_surface_runoff = np.any(
Q_surf_np > 0.00001)
if calculate_sediment_erosion_hillslope_based_on_surface_runoff == True:
# Adjustment factor is something that could be worked in at a later date.
adjustment_factor = 1
# Calculate the number of rainfall days per month and the average precipitation in each day over the month
day_pcp_month, day_avg_pcp = self.days_pcp_month(
total_day_month_precip, total_avg_month_precip)
# Calculate the monthly average half hour fraction
average_half_hour_fraction = hydrology.SCSCNQsurf(
).average_half_hour_rainfall(years_of_sim, day_pcp_month,
day_avg_pcp,
max_30min_rainfall_list,
adjustment_factor, self.index)
# Calculate Concetration Overland Flow
concentration_overland_flow = hydrology.SCSCNQsurf(
).time_concentration(depth_recking, flow_direction_raster,
slope, mannings_n, self.cell_size)
# Calculate Q peak and hru area
q_peak, hru_area = hydrology.SCSCNQsurf().peak_flow(
depth_recking, Q_surf_np, concentration_overland_flow,
flow_accumulation, average_half_hour_fraction,
self.cell_size)
# Calculate sediment erosion using MULSE
hillslope_sediment_erosion = MUSLE.hillslope_erosion_MUSLE(
slope, self.cell_size, GS_list,
active_layer_GS_P_temp).calculate_MUSLE(
Q_surf_np, q_peak, orgC, CULSE)
else:
hillslope_sediment_erosion = 0
arcpy.AddMessage("-------------------------")
arcpy.AddMessage(
"Insufficient surface runoff hillslope erosion will not be calculated"
)
arcpy.AddMessage("-------------------------")
else:
hillslope_sediment_erosion = 0
### Check what needs to be output from the model ###
self.week_day, self.month_day, self.year_day = rasterstonumpys.raster_outputs(
self.week_day, self.month_day, self.year_day,
self.current_date, self.first_loop, output_file_dict,
output_format, output_averages_temp, self.bottom_left_corner,
self.cell_size, Q_surf_np, Q_dis, depth_recking, precipitation,
hillslope_sediment_erosion, net_sediment)
### VARIABLES / PARAMETERS THAT CHANGE AT END OF LOOP ###
### Check if the DTM is a raster ###
self.first_loop = False
# Test using arcpy delete function
#arcpy.Delete_management(Q_dis)
#arcpy.Delete_management(Q_surf)
#arcpy.Delete_management(precipitation)
# Increment the date and day by 1
self.current_date = self.current_date + datetime.timedelta(days=1)
tomorrow = self.current_date + datetime.timedelta(days=1)
self.tomorrow_day = int(tomorrow.strftime('%d'))
self.day_of_year += 1
arcpy.AddMessage(
"Time to complete today is " +
str(round(time.time() - start, 2)) +
"s. Note that on day 1 and every 30 days the timestep will take longer."
)
arcpy.AddMessage("-------------------------")
del Q_dis, Q_surf_np, precipitation, Scurr
gc.collect()
### UNUSED CODE TO READD LATER ###
# Set up sediment loop save location
'''if discharge_file_location and discharge_file_location != "#":
for j in range(0, colNum):
if array[0][i][j] == BORDER_VALUE: #找到边界
for w in range(0, bandNum):
array[w][i][j] = noDataValue #赋值
print "替换:%d %d" % (i, j)
continue
elif array[0][i][j] == noDataValue: #是无值
continue
else: #是普通像素
break #退出该行
# 右
for i in range(0, rowNum):
for z in range(0, colNum):
j = colNum - 1 - z
if array[0][i][j] == BORDER_VALUE: #找到边界
for w in range(0, bandNum):
array[w][i][j] = noDataValue # 赋值
print "替换:%d %d" % (i, j)
continue
elif array[0][i][j] == noDataValue: #是无值
continue
else: #是普通像素
break #退出该行
#保存栅格
lowerLeft = arcpy.Point(r.extent.XMin, r.extent.YMin) #左下角点坐标
cellWidth = r.meanCellWidth #栅格宽度
cellHeight = r.meanCellHeight
newRaster = arcpy.NumPyArrayToRaster(array, lowerLeft, cellWidth,
cellHeight, noDataValue) #转换成栅格
newRaster.save(outPath) #保存
125. e[i,j] = 4500
126. if a[i,j] == -1:
127. if math.fabs(d17[i,j]* 0.05) >= math.fabs(d17[i,j] - d15[i,j]):
128. a[i,j] = d15[i,j]
129. e[i,j] = 4750
130. if a[i,j] == -1:
131. if math.fabs(d18[i,j]* 0.05) >= math.fabs(d18[i,j] - d16[i,j]):
132. a[i,j] = d16[i,j]
133. e[i,j] = 5000
134. if a[i,j] == -1:
135. if math.fabs(d19[i,j]* 0.05) >= math.fabs(d19[i,j] - d17[i,j]):
136. a[i,j] = d17[i,j]
137. e[i,j] = 5250
138. if a[i,j] == -1:
139. if math.fabs(d20[i,j]* 0.05) >= math.fabs(d20[i,j] - d18[i,j]):
140. a[i,j] = d18[i,j]
141. e[i,j] = 5500
142. if a[i,j] == -1:
143. if math.fabs(d20[i,j]* 0.05) >= math.fabs(d20[i,j] – d19[i,j]):
144. a[i,j] = d19[i,j]
145. e[i,j] = 5750
146. if a[i,j] == -1:
147. a[i,j] = d20[i,j]
148. e[i,j] = 6000
149. raster = arcpy.NumPyArrayToRaster (a, lower_left, dsc.meanCellWidth, dsc.meanCellHeight,noDataValue)
150. raster.save("amplituda")
151. raster2 = arcpy.NumPyArrayToRaster(e, lower_left, dsc.meanCellWidth, dsc.meanCellHeight,noDataValue)
152. raster2.save("velkost_okna")
153. del raster
154. del raster2
def execute_task(args):
in_extentDict, data, traj_list, noncroplist, croplist, cls, rws = args
fc_count = in_extentDict[0]
procExt = in_extentDict[1]
# ##print procExt
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
#The brilliant thing here is that using the extents with the full dataset!!!!!! DONT EVEN NEED TO CLIP THE FULL RASTER TO THE FISHNET BECASUE
arcpy.env.snapRaster = data['pre']['traj']['path']
arcpy.env.cellsize = data['pre']['traj']['path']
arcpy.env.outputCoordinateSystem = data['pre']['traj']['path']
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
print 'rws==================================', rws
print 'cls==================================', cls
# outData = numpy.zeros((rows,cols), numpy.int16)
outData = np.zeros((rws, cls), dtype=np.uint8)
### create numpy arrays for input datasets cdls and traj
cdls = {
2008:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2008',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2009:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2009',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2010:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2010',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2011:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2011',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2012:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2012',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2013:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2013',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2014:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2014',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2015:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2015',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2016:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2016',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls),
2017:
arcpy.RasterToNumPyArray(
in_raster=
'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\raster\\cdl.gdb\\cdl30_2017',
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls)
}
arr_traj = arcpy.RasterToNumPyArray(
in_raster=data['pre']['traj_yfc']['path'],
lower_left_corner=arcpy.Point(XMin, YMin),
nrows=rws,
ncols=cls)
# find the location of each pixel labeled with specific arbitray value in the rows list
for row in traj_list:
traj_value = row[0]
#year of conversion for either expansion or abandonmen
ytx = row[1]
##print 'ytx', ytx
#year before conversion for either expansion or abandonment
ybx = row[1] - 1
##print 'ybx', ybx
#Return the indices of the pixels that have values of the ytc arbitrsy values of the traj.
indices = (arr_traj == row[0]).nonzero()
#stack indices so easier to work with
stacked_indices = np.column_stack((indices[0], indices[1]))
#get the x and y location of each pixel that has been selected from above
for pixel_location in stacked_indices:
row = pixel_location[0]
col = pixel_location[1]
##print '---------- new pixel to analyze -----------------------------------'
#get the pixel value for ybx
pixel_value_ybx = cdls[ybx][row][col]
#print 'pixel_value_ybx', pixel_value_ybx
#get the pixel value for ytx
pixel_value_ytx = cdls[ytx][row][col]
#print 'pixel_value_ytx', pixel_value_ytx
#### find the years stil before in the time series for this pixel location
years_before_list = [i for i in data['global']['years'] if i < ytx]
#print 'years_before_list', years_before_list
list_before = []
for year in years_before_list:
list_before.append(cdls[year][row][col])
#print 'list_before', list_before
#### find the alue of the years after cy!?!
years_after_list = [i for i in data['global']['years'] if i >= ytx]
#print 'years_after_list', years_after_list
list_after = []
for year in years_after_list:
list_after.append(cdls[year][row][col])
#print 'list_after', list_after
list_entire = list_before + list_after
# print 'list_entire------------------------------------------->', list_entire
# print 'list_entire length', len(list_entire)
fuzzylist = [36, 37, 61, 152, 176]
fuzzycroplist = [58, 59, 60]
fruitlist = [
66, 67, 68, 69, 71, 72, 74, 75, 76, 77, 204, 210, 211, 212,
218, 220, 223
]
#### dev/fallow ######################################################
if (np.isin(list_before, noncroplist + [61]).all()) and ((np.isin(
list_after, [121, 122, 123, 124])).any() == False):
outData[row, col] = 101
####### fuzzylist ##############################
# if(np.isin(list_entire, fuzzylist).all()):
# outData[row,col] = 102
########### fuzzycroplist ############################
if (pixel_value_ybx in fuzzycroplist):
outData[row, col] = 105
#### fruit mask ##############################################################################################
if (np.isin(list_before, fruitlist).any()
and np.isin(list_after, fruitlist).any()):
outData[row, col] = 201
##### removed from mask for now ###################################################
# if traj_value == 238:
# # print 'bad traj'
# # outData[row,col] = data['refine']['arbitrary_crop']
# outData[row,col] = 202
### rice ####################################
#####needs to have rice before AND after to be considered false conversion
if (np.isin(list_before, [3]).any()) and (np.isin(list_after,
[3]).any()):
outData[row, col] = 204
### non-alfalfa ########################################
# if(np.isin(list_after, croplist + [37]).all()):
# outData[row,col] = 205
### 36_to_37 ###########################################
if (np.isin(list_before, [36, 37]).all()) and (np.isin(
list_after, croplist + [37]).all()):
outData[row, col] = 206
arcpy.ClearEnvironment("extent")
outname = "tile_" + str(fc_count) + '.tif'
# #create
outpath = os.path.join("C:/Users/Bougie/Desktop/Gibbs/data/", r"tiles",
outname)
# NumPyArrayToRaster (in_array, {lower_left_corner}, {x_cell_size}, {y_cell_size}, {value_to_nodata})
myRaster = arcpy.NumPyArrayToRaster(outData,
lower_left_corner=arcpy.Point(
XMin, YMin),
x_cell_size=30,
y_cell_size=30,
value_to_nodata=0)
##free memory from outdata array!!
outData = None
myRaster.save(outpath)
myRaster = None
def calculateMonteCarloIterationRaster(
dictactivities, matrixexcelfile, inputfolder, iteration_folder,
lower_left_corner, dsc, spatial_ref, iteration_outputname,
oceanrastername_with_path, iterations, starttime, starttimetobeupdated,
countScoreRasterIsTrue, changeScoreInputs, changeRankingMethod):
# preset parameters:
outputrasterlist = []
outputrasternamelist = []
outputextrarasterlist = []
outputextrarasternamelist = []
dfdesc = pd.read_excel(matrixexcelfile)
listOfLongActivityNames = dictactivities.keys()
firstmontecarloraster = True
# iterate through the Monte Carlo rounds:
for iteration in range(iterations):
starttimetobeupdated = gf.resetTime(starttimetobeupdated)
# create random factors for test 2 (change scoring scale):
if changeRankingMethod == "true":
# factor for 2.75:
factor_2_75 = gf.getRandomValueBetween0And1()
# factor for 2.50:
factor_2_50 = gf.getRandomValueBetween0And1()
# factor for 2.00:
factor_2_00 = gf.getRandomValueBetween0And1()
# factor for 1.75:
factor_1_75 = gf.getRandomValueBetween0And1()
# factor for 1.50:
factor_1_50 = gf.getRandomValueBetween0And1()
# factor for 1.25:
factor_1_25 = gf.getRandomValueBetween0And1()
# factor for 1.00:
factor_1_00 = gf.getRandomValueBetween0And1()
firstpairwiserasterinround = True
iterator1 = 0
iterator2 = 1
# get pairwise scores and turn them iteratively into total scores for the specific Monte Carlo round:
for column in listOfLongActivityNames:
inputrastername1 = dictactivities.get(
column) # get marine use raster 1
while iterator2 in range((iterator1 + 1),
len(listOfLongActivityNames)):
alldesc_nparray = dfdesc.loc[
dfdesc['Idcolumn'] == listOfLongActivityNames[iterator2],
column].values
# get scores:
if len(alldesc_nparray) > 0:
alldesc = alldesc_nparray.item(0)
if len(str(alldesc)) >= 4:
if alldesc[:1] == "-":
spec_score = float(alldesc[:5].replace(",", "."))
else:
spec_score = float(alldesc[:4].replace(",", "."))
inputrastername2 = dictactivities.get(
listOfLongActivityNames[iterator2]
) #get marine use raster 2
# create baseline total score raster where the score inputs stay unchanged and create an array that tracks the presence of conflicts/synergies:
if (firstmontecarloraster
== True) and (firstpairwiserasterinround
== True):
score_baseline = scoresToRasters3(
inputfolder, inputrastername1,
inputrastername2, spec_score)
cells_with_score_array = np.copy(score_baseline)
cells_with_score_array[
cells_with_score_array >
0.] = 1 #1 is to count the presence of a conflict or synergy
cells_with_score_array[
cells_with_score_array <
0.] = 1 #1 is to count the presence of a conflict or synergy
cells_with_score_array = cells_with_score_array.astype(
int)
elif (firstmontecarloraster == True):
score_baseline += scoresToRasters3(
inputfolder, inputrastername1,
inputrastername2, spec_score)
cells_with_score_array = gf.updateScoreCellCount(
score_baseline, cells_with_score_array,
"montecarlo")
# test 1: test score category input variability:
if changeScoreInputs == "true":
if spec_score == -3.00:
spec_score = (spec_score +
np.random.choice([0.00, 1.00]))
elif spec_score == -2.00:
spec_score = (
spec_score +
np.random.choice([-1.00, 0.00, 1.00]))
elif spec_score == -1.00:
spec_score = (
spec_score +
np.random.choice([-1.00, 0.00, 2.00]))
elif spec_score == 1.00:
spec_score = (spec_score + np.random.choice(
[-2.00, 0.00, 0.25, 0.50, 0.75, 1.00]))
elif spec_score == 1.25:
spec_score = (spec_score + np.random.choice(
[-2.25, -0.25, 0.00, 0.25, 0.50, 0.75]))
elif spec_score == 1.50:
spec_score = (spec_score + np.random.choice([
-0.50, -0.25, 0.00, 0.25, 0.50, 1.00, 1.25,
1.50
]))
elif spec_score == 1.75:
spec_score = (spec_score + np.random.choice([
-0.75, -0.50, -0.25, 0.00, 0.25, 0.75,
1.00, 1.25
]))
elif spec_score == 2.00:
spec_score = (spec_score + np.random.choice([
-1.00, -0.75, -0.50, -0.25, 0.00, 0.50,
0.75, 1.00
]))
elif spec_score == 2.50:
spec_score = (spec_score + np.random.choice([
-1.50, -1.25, -1.00, -0.75, -0.50, 0.00,
0.25, 0.50
]))
elif spec_score == 2.75:
spec_score = (spec_score + np.random.choice(
[-0.75, -0.25, 0.00, 0.25]))
elif spec_score == 3.00:
spec_score = (spec_score + np.random.choice(
[-1.00, -0.50, -0.25, 0.00]))
# test 2: test relative difference of scores (scoring scale):
if changeRankingMethod == "true":
if (spec_score == 2.75):
spec_score = 3.0 * factor_2_75
elif (spec_score == 2.50):
spec_score = (3.0 * factor_2_75) * factor_2_50
elif (spec_score == 2.00):
spec_score = ((3.0 * factor_2_75) *
factor_2_50) * factor_2_00
elif (spec_score == 1.75):
spec_score = ((
(3.0 * factor_2_75) * factor_2_50) *
factor_2_00) * factor_1_75
elif (spec_score == 1.50):
spec_score = (
(((3.0 * factor_2_75) * factor_2_50) *
factor_2_00) * factor_1_75) * factor_1_50
elif (spec_score == 1.25):
spec_score = ((((
(3.0 * factor_2_75) * factor_2_50) *
factor_2_00) * factor_1_75) *
factor_1_50) * factor_1_25
elif (spec_score == 1.00):
spec_score = (((
(((3.0 * factor_2_75) * factor_2_50) *
factor_2_00) * factor_1_75) * factor_1_50)
* factor_1_25) * factor_1_00
elif (spec_score == -2.00):
spec_score = ((-3.0 * factor_2_75) *
factor_2_50) * factor_2_00
elif (spec_score == -1.00):
spec_score = (((
(((-3.0 * factor_2_75) * factor_2_50) *
factor_2_00) * factor_1_75) * factor_1_50)
* factor_1_25) * factor_1_00
# create/update total score raster (score_outras_array) where the score inputs have changed based on the selected test/tests:
if firstpairwiserasterinround == True:
score_outras_array = scoresToRasters3(
inputfolder, inputrastername1,
inputrastername2, spec_score)
firstpairwiserasterinround = False
else:
score_outras_array += scoresToRasters3(
inputfolder, inputrastername1,
inputrastername2, spec_score)
iterator2 += 1 #iterate through all rasters that are after raster1 (to iteratively be raster2)
iterator1 += 1 #new raster1
iterator2 = iterator1 + 1 #start again by iterating through rasters to be raster2 (now the number of following rasters has decreased by 1)
# a Monte Carlo array is created if not existing already:
if firstmontecarloraster == True:
montecarlo_array = np.zeros_like(score_outras_array)
montecarlo_array = montecarlo_array.astype(float)
firstmontecarloraster = False
# the total score raster where the inputs have changed is updated to track the presence of conflicts (value=-1) and the presence of synergies (value=1) in the specific Monte Carlo round:
score_outras_array[score_outras_array > 0.] = 1
score_outras_array[score_outras_array < 0.] = -1
# The Monte Carlo array is counting the number of times in each Monte Carlo round that a raster returns with respectively synergies (value=1), conflicts (value=-1), or not any of the two (value=0):
montecarlo_array = montecarlo_array + score_outras_array
(printline,
starttimetobeupdated) = gf.printTime(starttime, starttimetobeupdated)
arcpy.AddMessage("iteration {} out of {} iterations, {}\n".format(
iteration + 1, iterations, printline))
# Some statistics numpy arrays are produced to adjust the final Monte Carlo raster:
ocean_array = arcpy.RasterToNumPyArray(
oceanrastername_with_path) # read ocean raster
ocean_array = ocean_array.astype(float) # convert ocean raster to float
if_land_in_ocean_array = ocean_array == 0 # get all zero values corresponding to land in the ocean raster
if_no_score_exist_array = cells_with_score_array == 0 # get all raster cells that have no pairwise scores
if_positive_baseline = score_baseline > 0.
if_negative_baseline = score_baseline < 0.
if_neutral_baseline = score_baseline == 0.
if_mostly_positive_iterations = montecarlo_array > 0.
if_average_neutral_iterations = montecarlo_array == 0.
if_mostly_negative_iterations = montecarlo_array < 0.
# Output raster 1: Make Monte Carlo main output raster counting the number of times each raster cell returns positive minus negative:
np.place(
montecarlo_array, if_land_in_ocean_array & if_no_score_exist_array,
np.nan
) # replace all zero values that are both land and zero in the total binary output of all iterations with NoData
scoreRasterOption1A = arcpy.NumPyArrayToRaster(montecarlo_array,
lower_left_corner,
dsc.meanCellWidth,
dsc.meanCellHeight)
(outputrasterlist, outputrasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_montecarlo_all",
scoreRasterOption1A, spatial_ref, outputrasterlist,
outputrasternamelist)
# Output raster 2 (optional): Make basis score raster where inputs are unchanged
if (countScoreRasterIsTrue == "true"):
np.place(score_baseline,
if_land_in_ocean_array & if_no_score_exist_array, np.nan)
basisScoreRaster = arcpy.NumPyArrayToRaster(score_baseline,
lower_left_corner,
dsc.meanCellWidth,
dsc.meanCellHeight)
gf.createNewPath(iteration_folder)
(outputextrarasterlist, outputextrarasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_basis_score",
basisScoreRaster, spatial_ref, outputextrarasterlist,
outputextrarasternamelist)
# Output raster 3: Make Monte Carlo main output raster with robust ("correct") positive/negative/neutral trends:
option1B_array = np.copy(montecarlo_array)
np.place(option1B_array,
((if_mostly_positive_iterations & if_negative_baseline) |
(if_mostly_negative_iterations & if_positive_baseline) |
(if_average_neutral_iterations & if_positive_baseline) |
(if_average_neutral_iterations & if_negative_baseline) |
(if_mostly_positive_iterations & if_neutral_baseline) |
(if_mostly_negative_iterations & if_neutral_baseline)),
np.nan) # set wrong values to NoData
scoreRasterOption1B = arcpy.NumPyArrayToRaster(option1B_array,
lower_left_corner,
dsc.meanCellWidth,
dsc.meanCellHeight)
(outputrasterlist, outputrasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_montecarlo_correct",
scoreRasterOption1B, spatial_ref, outputrasterlist,
outputrasternamelist)
# Output raster 4 (optional): Make basis score raster with robust ("correct") positive/negative/neutral trends:
if (countScoreRasterIsTrue == "true"):
option1Bscore_array = np.copy(score_baseline)
np.place(option1Bscore_array,
((if_mostly_positive_iterations & if_negative_baseline) |
(if_mostly_negative_iterations & if_positive_baseline) |
(if_average_neutral_iterations & if_positive_baseline) |
(if_average_neutral_iterations & if_negative_baseline) |
(if_mostly_positive_iterations & if_neutral_baseline) |
(if_mostly_negative_iterations & if_neutral_baseline)),
np.nan) # set wrong values to NoData
scoreRasterOption1Bscore = arcpy.NumPyArrayToRaster(
option1Bscore_array, lower_left_corner, dsc.meanCellWidth,
dsc.meanCellHeight)
(outputextrarasterlist, outputextrarasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_score_correct",
scoreRasterOption1Bscore, spatial_ref, outputextrarasterlist,
outputextrarasternamelist)
# Output raster 5: Make Monte Carlo main output raster with sensitive ("wrong") positive/negative/neutral trends:
option1C_array = np.copy(montecarlo_array)
np.place(option1C_array,
((if_mostly_positive_iterations & if_positive_baseline) |
(if_mostly_negative_iterations & if_negative_baseline) |
(if_average_neutral_iterations & if_neutral_baseline)),
np.nan) # set correct values to NoData
scoreRasterOption1C = arcpy.NumPyArrayToRaster(option1C_array,
lower_left_corner,
dsc.meanCellWidth,
dsc.meanCellHeight)
(outputrasterlist, outputrasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_montecarlo_wrong",
scoreRasterOption1C, spatial_ref, outputrasterlist,
outputrasternamelist)
# Output raster 6(optional): Make basis score raster with sensitive ("wrong") positive/negative/neutral trends:
if (countScoreRasterIsTrue == "true"):
option1Cscore_array = np.copy(score_baseline)
np.place(option1Cscore_array,
((if_mostly_positive_iterations & if_positive_baseline) |
(if_mostly_negative_iterations & if_negative_baseline) |
(if_average_neutral_iterations & if_neutral_baseline)),
np.nan) # set correct values to NoData
scoreRasterOption1Cscore = arcpy.NumPyArrayToRaster(
option1Cscore_array, lower_left_corner, dsc.meanCellWidth,
dsc.meanCellHeight)
(outputextrarasterlist, outputextrarasternamelist) = gf.createRaster(
iteration_folder, iteration_outputname, "_score_wrong",
scoreRasterOption1Cscore, spatial_ref, outputextrarasterlist,
outputextrarasternamelist)
return (outputrasterlist, outputrasternamelist, outputextrarasterlist,
outputextrarasternamelist)
