def slp_asp_to_ell(DEM):
'''Fit ellipse against a given clipped DEM'''
#Generate slope with GDAL
slp = tmpdir + str(np.random.randint(0,1e6)) + '_reproj_slope.tif'
gdal_comm = ['gdaldem', 'Slope', '-compute_edges', DEM, slp]
process = subprocess.Popen(gdal_comm, stdout=subprocess.PIPE, stderr=FNULL)
process.communicate()
_ = process.wait()
if not os.path.exists(slp):
time.sleep(1)
#Generate aspect with GDAL
asp = tmpdir + str(np.random.randint(0,1e6)) + '_reproj_aspect.tif'
gdal_comm = ['gdaldem', 'Aspect', '-compute_edges', DEM, asp]
process = subprocess.Popen(gdal_comm, stdout=subprocess.PIPE, stderr=FNULL)
process.communicate()
_ = process.wait()
if not os.path.exists(asp):
time.sleep(1)
#Load in the data and mask out NaNs
slope = np.array(gdalnumeric.LoadFile(slp).astype(float))
slope[slope < 0] = np.nan
aspect = np.array(gdalnumeric.LoadFile(asp).astype(float))
aspect[aspect < 0] = np.nan
ell, out_raw = fit_ellipse(slope, aspect)
#Pull the center, eccentricity, and north/east steepening from the ellipse
metadata = ell_meta(ell)
return ell, out_raw, metadata
def array_stack(ndvi,qflag,xrows1,xrows2,yrows1,yrows2): #this should be list
index=np.arange(0,len(ndvi))
arrstack=np.empty(shape=(46,abs(xrows2-xrows1),abs(yrows2-yrows1))) #dtype=float
for nv,q,x in itertools.izip(ndvi,qflag,index):
arrndvi=gdalnumeric.LoadFile(nv)[xrows1:xrows2,yrows1:yrows2]
#print "%s, x1=%s, x2=%s, y1=%s, y2=%s" %(nv,xrows1,xrows2,yrows1,yrows2)
arrqflag=gdalnumeric.LoadFile(q)[xrows1:xrows2,yrows1:yrows2]
mask_clouds=np.where(arrqflag==3,np.nan,arrndvi)
arrstack[x,:,:]=mask_clouds
return arrstack
def openImgs(img_files, gt_files, maps, only_img=False):
imgs = [None] * len(img_files)
gts = [None] * len(img_files)
for m in maps:
#print img_files[m]
#print gt_files[m]
imgs[m] = gdalnumeric.LoadFile(img_files[m])
if not only_img:
gts[m] = gdalnumeric.LoadFile(gt_files[m])
return imgs, gts
def open(self, file=None, dtype=None):
"""
Open a local file handle for reading and assignment
:param file:
:return: None
"""
# args[0]/file=
if file is None:
raise IndexError("invalid file= argument provided")
# grab raster meta information from GeoRasters
try:
self.ndv, self.x_cell_size, self.y_cell_size, self.geot, self.projection, self.dtype = \
get_geo_info(file)
except Exception:
raise AttributeError("problem processing file input -- is this",
"a raster file?")
# args[1]/dtype=
if dtype is not None:
# override our shadow'd value from GeoRasters if
# something was specified by the user
self.dtype = dtype
# re-cast our datatype as a numpy type, if needed
if type(self.dtype) == str:
self.dtype = NUMPY_TYPES[self.dtype.lower()]
if self.ndv is None:
self.ndv = _DEFAULT_NA_VALUE
# low-level call to gdal with explicit type specification
# that will store in memory or as a disc cache, depending
# on the state of our _using_disc_caching property
if self._using_disc_caching is not None:
# create a cache file
self.array = np.memmap(self._using_disc_caching,
dtype=dtype,
mode='w+',
shape=(_x_size, _y_size))
# load file contents into the cache
self.array[:] = gdalnumeric.LoadFile(
filename=self.filename,
buf_type=gdal_array.NumericTypeCodeToGDALTypeCode(
self.dtype))[:]
# by default, load the whole file into memory
else:
self.array = gdalnumeric.LoadFile(
filename=self.filename,
buf_type=gdal_array.NumericTypeCodeToGDALTypeCode(self.dtype))
# make sure we honor our no data value
self.array = np.ma.masked_array(self.array,
mask=self.array == self.ndv,
fill_value=self.ndv)
def produceClassifyTif(srcTifPath, classify, outClassifyTifPath):
dataset = gdal.Open(srcTifPath)
width = dataset.RasterXSize
height = dataset.RasterYSize
bands = dataset.RasterCount
data = dataset.ReadAsArray(0, 0, width, height)
geotransform = dataset.GetGeoTransform()
proj = dataset.GetProjection()
band = dataset.GetRasterBand(1)
noDataValue = band.GetNoDataValue()
src_image = gdalnumeric.LoadFile(srcTifPath)
dst_image = numpy.zeros((height, width))
for class_info in classify:
class_id = class_info[0]
class_start = class_info[1]
class_end = class_info[2]
class_value = numpy.ones((height, width)) * class_id
mask = numpy.bitwise_and(
numpy.greater_equal(src_image, class_start),
numpy.less_equal(src_image, class_end))
dst_image = numpy.choose(mask, (dst_image, class_value))
writeTiff(dst_image, width, height, bands, geotransform, proj, noDataValue, outClassifyTifPath)
def doit(src_filename, dst_filename):
class_defs = [(1, 10, 20),
(2, 20, 30),
(3, 128, 255)]
src_ds = gdal.Open(src_filename)
xsize = src_ds.RasterXSize
ysize = src_ds.RasterYSize
src_image = gdalnumeric.LoadFile(src_filename)
dst_image = numpy.zeros((ysize, xsize))
for class_info in class_defs:
class_id = class_info[0]
class_start = class_info[1]
class_end = class_info[2]
class_value = numpy.ones((ysize, xsize)) * class_id
mask = numpy.bitwise_and(
numpy.greater_equal(src_image, class_start),
numpy.less_equal(src_image, class_end))
dst_image = numpy.choose(mask, (dst_image, class_value))
gdalnumeric.SaveArray(dst_image, dst_filename)
def numpy_rw_5():
if gdaltest.numpy_drv is None:
return 'skip'
import gdalnumeric
array = gdalnumeric.LoadFile('data/rgbsmall.tif', 35, 21, 1, 1)
if array[0][0][0] != 78:
print(array)
gdaltest.post_reason('value read improperly.')
return 'fail'
if array[1][0][0] != 117:
print(array)
gdaltest.post_reason('value read improperly.')
return 'fail'
if array[2][0][0] != 24:
print(array)
gdaltest.post_reason('value read improperly.')
return 'fail'
return 'success'
def changeDetection(image1, image2, outputname):
ar1 = gdalnumeric.LoadFile(image1).astype(np.int8)
ar2 = gdalnumeric.LoadFile(image2)[1].astype(np.int8)
diff = ar2 - ar1
classes = np.histogram(diff, bins=5)[1]
lut = [[0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,255,0], [255,0,0]]
start = 1
rgb = np.zeros((3, diff.shape[0], diff.shape[1],), np.int8)
for i in range(len(classes)):
mask = np.logical_and(start <= diff, diff <= classes[i])
for j in range(len(lut[i])):
rgb[j] = np.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 1
gdal_array.SaveArray(rgb, outputname, format="GTiff")
def rasterShow(self, rasterFp):
try:
rasterArray=gdalnumeric.LoadFile(rasterFp) #加载栅格数据为gdal数组格式
except RuntimeError:
print("Unable to open %s"%rasterFp)
multiple=2 #配置图像大小的倍数
fig=plt.figure(figsize=(20*multiple, 12*multiple))
ax=fig.add_subplot(111)
plt.xticks([x for x in range(rasterArray.shape[0]) if x%200==0])
plt.yticks([y for y in range(rasterArray.shape[0]) if y%200==0])
ax.imshow(rasterArray)
def rasterShow(fn, rasterImageName):
NDVIPath = os.path.join(fn, rasterImageName)
try:
rasterArray = gdalnumeric.LoadFile(NDVIPath) #加载栅格数据为gdal数组格式
except RuntimeError:
print("Unable to open %s" % rasterPath)
fig = plt.figure(figsize=(20, 12))
ax = fig.add_subplot(111)
plt.xticks([x for x in range(rasterArray.shape[0]) if x % 200 == 0])
plt.yticks([y for y in range(rasterArray.shape[0]) if y % 200 == 0])
ax.imshow(rasterArray)
def open(self, file=None):
"""Does what it says."""
self.ndv, self.xsize, self.ysize, self.geot, self.projection, datatype = georasters.get_geo_info(
file)
if self.ndv is None:
self.ndv = -99999
self.array = gdalnumeric.LoadFile(file)
self.y_cell_size = self.geot[1]
self.x_cell_size = self.geot[5]
self.array = numpy.ma.masked_array(self.array,
mask=self.array == self.ndv,
fill_value=self.ndv)
def getGroundTruth(folders, testing=False):
files = []
for f in folders:
for gt in os.listdir(os.path.join(f, "GroundTruths")):
if ".png" in gt:
files.append(os.path.join(f, "GroundTruths", gt))
names = [os.path.split(gt.split('.png')[0])[-1] for gt in files]
gts = [gdalnumeric.LoadFile(os.path.join(f)) for f in files]
preds = [np.zeros((2, g.shape[0], g.shape[1])) for g in gts]
if testing:
del gts
gts = None
return gts, preds, names
def load_inputs(input_csv, csv_epsg, flow_directions_file):
"""Load input files and reproject CSV to same projection and flow directions
"""
raster = gdal.Open(flow_directions_file)
flow_directions = gdalnumeric.LoadFile(flow_directions_file)
input_df = pd.read_csv(input_csv)
# Reproject vector geometry to same projection as raster
sourceSR = osr.SpatialReference()
sourceSR.ImportFromEPSG(csv_epsg)
targetSR = osr.SpatialReference()
targetSR.ImportFromWkt(raster.GetProjectionRef())
coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)
geoTrans = raster.GetGeoTransform()
return (input_df, flow_directions, coordTrans, geoTrans)
def basic_region_analysis(self, cview, clayer):
import Numeric, gdalnumeric
line = int(self.RP_ToolDlg.entry_dict['start_line'].get_text())
pix = int(self.RP_ToolDlg.entry_dict['start_pix'].get_text())
sl = int(self.RP_ToolDlg.entry_dict['num_lines'].get_text())
sp = int(self.RP_ToolDlg.entry_dict['num_pix'].get_text())
clayer = self.app.sel_manager.get_active_layer()
if clayer is None:
# Target can only be extracted if a layer is selected
return 'No selected raster layer'
dsb = clayer.get_data(0).get_band()
# Modify default to be whole image.
if sl is 1 and sp is 1 and line is 1 and pix is 1:
sl = dsb.YSize - line + 1
sp = dsb.XSize - pix + 1
# Create a temporary band for sampling if we have a subrect.
temp_copy = 0
if line != 1 or pix != 1 or sp != dsb.XSize or sl != dsb.YSize:
# print line, pix, sp, sl
temp_copy = 1
filename = clayer.get_parent().get_dataset().GetDescription()
target_data = gdalnumeric.LoadFile(filename, pix - 1, line - 1, sp,
sl)
target_ds = gdalnumeric.OpenArray(target_data)
dsb = target_ds.GetRasterBand(1)
# Compute the histogram.
x_min = clayer.min_get(0)
x_max = clayer.max_get(0)
histogram = dsb.GetHistogram(x_min, x_max, 256, 1, 0)
y_min = 0
y_max = max(histogram[1:-1])
(pm, mask) = self.RP_ToolDlg.get_histview(histogram, x_min, x_max,
y_min, y_max)
self.RP_ToolDlg.viewarea.set(pm, mask)
def balancePatches(targetPoints,
relevantPoints,
groundTruthList,
patchSize,
leftoverPercentage=0.05):
balancedRelevantPoints = []
if leftoverPercentage > 1:
print "Error: leftoverPercentage is greater than 1."
return targetPoints, relevantPoints
for i, tlist in enumerate(targetPoints):
totalTpixels = 0
partialRpixels = 0
data = (gdalnumeric.LoadFile(groundTruthList[i]) > 0).astype(int)
print data.shape
for pos in targetPoints[i]:
#if i % 10 == 0:
#print data[pos[1]:pos[1]+patchSize, pos[2]:pos[2]+patchSize]
b = np.bincount(data[pos[1]:pos[1] + patchSize,
pos[2]:pos[2] + patchSize].flatten())
print b[0], b[1]
totalTpixels += b[1]
partialRpixels += b[0]
print(i, totalTpixels)
data = None
del data
totalAddRpixels = max(0.0, ((1 - leftoverPercentage) * totalTpixels) -
partialRpixels)
print totalAddRpixels
totalRpatches = int(math.ceil(totalAddRpixels / float(patchSize**2)))
print "## Numero de pixels de erosao:{0} \n## Numero de pixels de nao-erosao:{1}".format(
totalTpixels, totalAddRpixels + partialRpixels)
print(len(relevantPoints[i]), totalRpatches)
balancedRelevantPoints.append(
random.sample(relevantPoints[i],
min(len(relevantPoints[i]), totalRpatches)))
return np.asarray(targetPoints,
dtype=object), np.asarray(balancedRelevantPoints,
dtype=object)
def produceMaskTif(srcTifPath, maskTifPath):
dataset = gdal.Open(srcTifPath)
width = dataset.RasterXSize
height = dataset.RasterYSize
bands = dataset.RasterCount
srcArray = dataset.ReadAsArray(0, 0, width, height)
geotransform = dataset.GetGeoTransform()
proj = dataset.GetProjection()
band = dataset.GetRasterBand(1)
noDataValue = band.GetNoDataValue()
src_image = gdalnumeric.LoadFile(srcTifPath)
mask_image = numpy.zeros((height, width))
for i in range(0, height):
for j in range(0, width):
if not srcArray[i][j] - noDataValue <= 1e-9:
mask_image[i][j] = 1
writeTiff(mask_image, width, height, bands, geotransform, proj, noDataValue, maskTifPath)
def createData(imgfile, gt, outputfolder, references, geotransform, size):
#print "Opening img: {}".format(imgfile)
data = gdalnumeric.LoadFile(imgfile)
#print "Done opening img: {}".format(imgfile)
if not os.path.exists(outputfolder):
os.mkdir(outputfolder)
if not os.path.exists(os.path.join(outputfolder, 'JPEGImages')):
os.mkdir(os.path.join(outputfolder, 'JPEGImages'))
if not os.path.exists(os.path.join(outputfolder, 'Masks')):
os.mkdir(os.path.join(outputfolder, 'Masks'))
imgfilesplit = os.path.splitext(os.path.split(imgfile)[-1])
for num, point in enumerate(references):
outputfileimg = os.path.join(
outputfolder, 'JPEGImages',
imgfilesplit[0] + '_crop' + str(num) + '.jpg')
outputfilemask = os.path.join(
outputfolder, 'Masks',
imgfilesplit[0] + '_crop' + str(num) + '_mask.jpg')
#print "Creating files: \t{0}{1}".format(outputfileimg, outputfilemask)
cropImg(data, point, outputfileimg, size)
cropImg(gt, point, outputfilemask, size)
def open(self):
"""
Read a raster file from disc as a formatted numpy array
:rval none:
"""
# grab raster meta informationP from GeoRasters
try:
self.ndv, self.x_size, self.y_size, self.geot, self.projection, self.dtype = get_geo_info(
self.filename)
except Exception:
raise AttributeError("problem processing file input -- is this" +
" a raster file?")
# call gdal with explicit type specification
# that will store in memory or as a disc cache, depending
# on the state of our use_disc_caching property
if self.use_disc_caching is True:
# create a cache file and load file contents into the cache
_cached_file = NdArrayDiscCache(
input=self.filename,
dtype=self.dtype,
x_size=self.x_size,
y_size=self.y_size,
)
self.array = _cached_file.array
self.disc_cache_file = _cached_file.disc_cache_file
# by default, load the whole file into memory
else:
self.array = gdalnumeric.LoadFile(
filename=self.filename,
buf_type=gdal_array.NumericTypeCodeToGDALTypeCode(
_to_numpy_type(self.dtype)),
)
# make sure we honor our no data value
self.array = np.ma.masked_array(self.array,
mask=self.array == self.ndv,
fill_value=self.ndv)
def numpy_rw_2():
if gdaltest.numpy_drv is None:
return 'skip'
import gdalnumeric
array = gdalnumeric.LoadFile('data/utmsmall.tif')
if array is None:
gdaltest.post_reason('Failed to load utmsmall.tif into array')
return 'fail'
ds = gdalnumeric.OpenArray(array)
if ds is None:
gdaltest.post_reason('Failed to open memory array as dataset.')
return 'fail'
bnd = ds.GetRasterBand(1)
if bnd.Checksum() != 50054:
gdaltest.post_reason('Didnt get expected checksum on reopened file')
return 'fail'
ds = None
return 'success'
y_ratio = 450.0 / pixels
# Add more colors to this list if comparing
# more than 3 bands or 1 image
colors = ["red", "green", "blue"]
for j in range(len(hist)):
h = hist[j]
x = -354
y = -199
t.up()
t.goto(x, y)
t.down()
t.color(colors[j])
for i in range(256):
x = i * x_ratio
y = h[i] * y_ratio
x = x - (709 / 2)
y = y + -199
t.goto((x, y))
os.chdir(r'C:\Users\Fabio\Downloads\Studio\landsat\LC81910312016217LGN00')
im = "falco.tif"
histograms = []
arr = gdalnumeric.LoadFile(im)
for b in arr:
histograms.append(histogram(b))
draw_histogram(histograms, scale=False)
t.pen(shown=False)
t.done()
def __init__(self, hdfFile, MOD11A1, h5File, ndv=None):
# Product subdataset information
gq_lst = 0 # 1km LST
gq_red = 1 # 250m red band
gq_nir = 2 # 250m NIR band
# Open and find subdatasets
gq_ds = gdal.Open(hdfFile, gdal.GA_ReadOnly) # MODIS
mod11_ds = gdal.Open(MOD11A1, gdal.GA_ReadOnly) # MODIS
self.sm_ds = gdal.Open(h5File, gdal.GA_ReadOnly) # SMAP
# Read in datasets
self.array_sm = gdalnumeric.LoadFile(h5File)
ds_red = gdal.Open(gq_ds.GetSubDatasets()[gq_red][0],
gdal.GA_ReadOnly) # MODIS Dataset
ds_nir = gdal.Open(gq_ds.GetSubDatasets()[gq_nir][0],
gdal.GA_ReadOnly) # MODIS Dataset
ds_lst = gdal.Open(mod11_ds.GetSubDatasets()[gq_lst][0],
gdal.GA_ReadOnly) # MODIS Dataset
# Wrap To WGS84
geotref = ds_red.GetProjectionRef()
geoTransform = ds_red.GetGeoTransform()
# pixel = geoTransform[1] / 100000
pixel = 0.001853250866278332
# MOD11A1 Geotransform
geotref_lst = ds_lst.GetProjectionRef()
geoTransform_lst = ds_lst.GetGeoTransform()
pixel_lst = geoTransform_lst[1] / 100000
self.w_ds_red = self.reproject_dataset(dataset=ds_red,
pixel_spacing=pixel,
epsg_from=geotref,
epsg_to=4326)
self.w_ds_nir = self.reproject_dataset(dataset=ds_nir,
pixel_spacing=pixel,
epsg_from=geotref,
epsg_to=4326)
self.w_ds_lst = self.reproject_dataset(dataset=ds_lst,
pixel_spacing=pixel_lst,
epsg_from=geotref_lst,
epsg_to=4326)
# Write out image
red = self.w_ds_red.GetRasterBand(1).ReadAsArray().astype(float)
nir = self.w_ds_nir.GetRasterBand(1).ReadAsArray().astype(float)
lst = self.w_ds_lst.GetRasterBand(1).ReadAsArray().astype(float)
# masking invalid values
eqn = '(red <= 0) | (red >= 10000) | (nir <= 0) | (nir >= 10000)'
invalid = ne.evaluate(eqn)
# Apply valid range mask to data
red[invalid] = ndv
nir[invalid] = ndv
# Set Variabels
self.red = red
self.nir = nir
self.lst = ne.evaluate('(lst / 50.0)').astype(float)
self.sm = self.Cilpper(srcArray=self.array_sm,
smapDataset=self.sm_ds,
modisWrap=self.w_ds_lst)
self.clippedSM = self.smapClipRsizer(modisWrap=self.w_ds_lst,
clipArray=self.smapClipped,
transform=self.clippedGeotranse)
self.ndvi = self.NDVI()
self.fvc = self.FVC()
self.fv1km = self.resmapleFvc(fvc250m=self.fvc, lst1km=self.lst)
self.Tv1km = self.calculateTv1km(LST=self.lst, FVC=self.fv1km)
self.Ts1km = self.calculateTs1km(Tmodis=self.lst,
fv1km=self.fv1km,
Tv1km=self.Tv1km)
self.see = self.SEEMODIS1km(
Ts1km=self.Ts1km) #, Tsmax=self.Tsmax, Tsmin=self.Tsmin)
self.SEE40km = self.calculateMeanSEE(SEE=self.see, clip=self.sm)
self.SEEavg = self.SEEMean(modisWrap=self.w_ds_lst,
seeMean=self.SEE40km,
transform=self.clippedGeotranse)
self.smp = self.soilMoistureParameter(rescaleSMAP=self.clippedSM,
rescaleMeanSEE=self.SEEavg)
self.rescalclippedSM = self.smapClipRsizer(
modisWrap=self.w_ds_lst,
clipArray=self.smapClipped,
transform=self.clippedGeotranse)
self.disaggregated = self.Disaggregation(
rescaleSMAP=self.rescalclippedSM,
rescaleMeanSEE=self.SEEavg,
SEEmodis1km=self.see,
SMp=self.smp)
@author:richieBao-caDesign设计(cadesign.cn)
借鉴SIR传染病模型
"""
import gdal, ogr, os, osr, gdalnumeric
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from scipy.ndimage.filters import convolve
import moviepy.editor as mpy
import time
'''读取“空间用地分类”.tif地理信息数据'''
#rasterPath=r'D:\MUBENAcademy\pythonSystem\dataA\testClip6.tif'
rasterPath = r'C:\Users\Richi\Music\SIR\testClip6.tif'
try:
srcArray = gdalnumeric.LoadFile(rasterPath) #加载栅格数据为gdal数组格式
except RuntimeError:
print("Unable to open %s" % rasterPath)
print(srcArray.shape)
originalRaster = srcArray.copy()
print(np.unique(originalRaster))
uniqueValues = np.unique(srcArray)
#print(uniqueValues)
'''配置空间阻力并归一化到[0,1]'''
#costMapping_LandType={"空值A":(0,0),"空值B":(256,0),"农田":(2,1),"河流":(3,7),"建设":(4,0),"森林山":(5,10),"森林平":(6,10)}
costMapping_LandType = {
"空值A": (0, 0),
"空值B": (256, 0),
"农田": (2, 200),
"河流": (3, 500),
"建设": (4, 0),
dst_segmentation = "/home/vortex/Desktop/LAYERS/lorenzo/tiles/1995/Mosaic/test_clipped/enanched_sobel_seg.tif"
# image = Image.open(src)
#
#
# im = image.convert('L')
# contr = ImageEnhance.Contrast(im)
# im = contr.enhance(2)
# # bright = ImageEnhance.Brightness(im)
# # im = bright.enhance(1)
# im.save(dst, "tiff")
# sobel2
# SEGMENTATION
image_array = gdalnumeric.LoadFile(src)
for a in image_array:
print("a %s") % a
print("-----------")
for b in a:
print("%s") % b
break
markers = np.zeros_like(image_array)
markers[image_array < 90] = 1
markers[image_array > 90] = 2
markers[image_array > 110] = 3
# print image_array
# print markers
segmentation = watershed(image_array, markers)
def __init__(self, input=None, **kwargs):
"""
ArrayDiscCache helps build a local numpy memmap file and either loads raster data from disc into the cache,
or attempts a direct assignment of a user-specific numpy array to a cache file (via the input= argument).
:param str input: Either a full path to a raster file memmap'd to disk or an nd array object that is mapped directly
:param str dtype: Numpy datatype specification to use for our array cache
:param str x_size: Number of cells (x-axis) to use for our array cache
:param str y_size: Number of cells (y-axis) to use for our array cache
"""
self.disc_cache_file = os.path.abspath(
kwargs.get("cache_filename",
str(randint(1, 9e09)) + "_np_array.dat"))
self.dtype = kwargs.get("dtype", _DEFAULT_DTYPE)
self.x_size = kwargs.get("x_size", None)
self.y_size = kwargs.get("y_size", None)
self.ndv = kwargs.get("ndv", _DEFAULT_NA_VALUE)
LOGGER.debug("Using disc caching file for large numpy array: " +
self.disc_cache_file)
# if the user specified a valid file path or numpy array object, try to read it into our cache
# but otherwise allow an empty specification
if input is None:
# by default, just create an empty cache file from the parameters specified by the user
self.array = np.memmap(
filename=self.disc_cache_file,
dtype=_to_numpy_type(self.dtype),
mode="w+",
shape=(self.y_size, self.x_size),
)
else:
if os.path.isfile(input):
LOGGER.debug("Loading file contents into disc cache file:" +
self.disc_cache_file)
_raster_file = gdal.Open(input)
self.array = np.memmap(
filename=self.disc_cache_file,
dtype=_to_numpy_type(self.dtype),
mode="w+",
shape=(_raster_file.RasterYSize, _raster_file.RasterXSize),
)
del _raster_file
self.array[:] = gdalnumeric.LoadFile(
filename=input,
buf_type=gdal_array.NumericTypeCodeToGDALTypeCode(
_to_numpy_type(self.dtype)),
)[:]
else:
LOGGER.debug(
"Treating input= object as numpy array object and reading into disc cache file:"
+ self.disc_cache_file)
self.array = np.memmap(
filename=self.disc_cache_file,
dtype=input.dtype,
mode="w+",
shape=input.shape,
)
self.array[:] = input[:]
#******************************************************************************
from osgeo import gdal
import gdalnumeric
try:
import numpy
except ImportError:
import Numeric as numpy
class_defs = [(1, 10, 20), (2, 20, 30), (3, 128, 255)]
src_ds = gdal.Open('utm.tif')
xsize = src_ds.RasterXSize
ysize = src_ds.RasterYSize
src_image = gdalnumeric.LoadFile('utm.tif')
dst_image = numpy.zeros((ysize, xsize))
for class_info in class_defs:
class_id = class_info[0]
class_start = class_info[1]
class_end = class_info[2]
class_value = numpy.ones((ysize, xsize)) * class_id
mask = numpy.bitwise_and(numpy.greater_equal(src_image, class_start),
numpy.less_equal(src_image, class_end))
dst_image = numpy.choose(mask, (dst_image, class_value))
import gdalnumeric
#Input File
src = "../dati/islands/islands.tif"
#Output
tgt = "../dati/islands/islands_classified.jpg"
srcArr = gdalnumeric.LoadFile(src)
classes = gdalnumeric.numpy.histogram(srcArr, bins=2)[1]
print classes
#Color look-up table (LUT) - must be len(classes)+1.
#Specified as R,G,B tuples
lut = [[255, 0, 0], [0, 0, 0], [255, 255, 255]]
start = 1
rgb = gdalnumeric.numpy.zeros((
3,
srcArr.shape[0],
srcArr.shape[1],
), gdalnumeric.numpy.float32)
# Process all classes and assign colors
for i in range(len(classes)):
mask = gdalnumeric.numpy.logical_and(start <= srcArr, srcArr <= classes[i])
for j in range(len(lut[i])):
rgb[j] = gdalnumeric.numpy.choose(mask, (rgb[j], lut[i][j]))
start = classes[i] + 1
QRslp[mask] = np.nan
QRasp[mask] = np.nan
return QRslp, QRasp
#Loop through each DEM resolution
base_dir = '~/example/'
spacings = range(2, 31)[::-1]
qr_s, qr_a = [], []
for i in spacings:
dem = base_dir + 'DEM/Pozo_UTM11_NAD83_g_' + str(i) + 'm.tif'
uncertainty = base_dir + 'STD/Pozo_UTM11_NAD83_g_' + str(i) + 'm_std.tif'
#Load the data as arrays
elev = gdalnumeric.LoadFile(dem).astype(float)
std = gdalnumeric.LoadFile(uncertainty).astype(float)
#Mask out water areas
mask = np.where(elev < 0)
elev[mask] = np.nan
std[mask] = np.nan
#Calculate the Quality Ratios
QRslp, QRasp = QR(elev, i, std, mask)
QRslp[mask] = np.nan
QRasp[mask] = np.nan
#Append the QR mean values to a list
qr_s.append(np.nanmean(QRslp))
qr_a.append(np.nanmean(QRasp))
valid_date_path = os.path.join(stats_folder, 'valid_date.csv')
# step1: calculate cloud cover ##############################################################
print 'step1: calculate cloud cover '
# load data
snow_date = pd.DataFrame.from_csv(model_snow_date_path, header=0)
snow_date['modis_cloud_cover'] = ''
snow_date['modis_snow_count'] = ''
# calculate the modis cloud cover and check whether it has snow
for time in snow_date.index:
modis_proj_path = snow_date['modis_proj_folder'].ix[time]
if os.path.isfile(modis_proj_path):
try:
raster = gdalnumeric.LoadFile(modis_proj_path)
cloud_count = (raster[0] == 250).sum()
total_count = raster.shape[1] * raster.shape[2]
nodata_count = (raster[0] == 255).sum()
snow_count = ((raster[0] >= modis_threshold) &
(raster[0] <= 100)).sum()
cloud_cover = float(cloud_count) / (total_count - nodata_count)
snow_date['modis_cloud_cover'].ix[time] = cloud_cover
snow_date['modis_snow_count'].ix[time] = snow_count
except Exception as e:
continue
snow_date.to_csv(model_snow_date_path)
# step2: get valid date #######################################################################
# this is to find the date that snow17, ueb or modis has snow (>0m or 0%) and modis cloud cover less than threshold
processing.runalg("gdalogr:warpreproject", rasterLyr, srs,srs, res, 0, None, 0, "/qgis_data/rasters/resampled.tif")
# Verify that the resampled.tif image was created in your /qgis_data/rasters directory.
#========================================================
# Resampling raster resolution
#========================================================
#Remotely-sensed images are not just pictures; they are data. The value of the pixels has
#meaning that can be automatically analyzed by a computer
#Numpy can be accessed through the GDAL package's gdalnumeric module.
#we must import the bridge module called gdalnumeric, which connects GDAL
#to Numpy in order to perform an array math on geospatial images:
import gdalnumeric
# Now, we will load our raster image directly into a multidimensional array:
a = gdalnumeric.LoadFile("/qgis_data/rasters/satimage.tif")
# The following code counts the number of pixel combinations in the image:
b = a.T.ravel()
c=b.reshape((b.size/3,3))
order = gdalnumeric.numpy.lexsort(c.T)
c = c[order]
diff = gdalnumeric.numpy.diff(c, axis=0)
ui = gdalnumeric.numpy.ones(len(c), 'bool')
ui[1:] = (diff != 0).any(axis=1)
u = c[ui]
# Now, we can take a look at the size of the resulting one-dimensional array to get the unique values count:
u.size
#========================================================
# Mosaicing rasters
pixel_count_path = os.path.join(
stats_folder,
'pixel_count_{}.csv'.format(swe_col_name.split('_')[0]))
# get pixel count
for time in snow_date.index:
modis_proj_path = os.path.join(
modis_proj_folder, snow_date['modis_proj_folder'].ix[time])
swe_proj_path = os.path.join(swe_proj_folder,
snow_date[swe_col_name].ix[time])
if os.path.isfile(swe_proj_path) and os.path.isfile(
modis_proj_path):
try:
# count watershed, watershed_out, invalid pixels
modis = gdalnumeric.LoadFile(modis_proj_path)
sca_data = modis[0] / 100.0
modis_bin = np.where(modis[1] != 0, sca_data, -999)
count_watershed = (modis[1] == 255).sum()
count_watershed_out = (modis[1] == 0).sum()
count_invalid = (modis_bin > 100).sum()
# get moids binary
modis_bin[modis_bin > 100] = -999
modis_bin[modis_bin > 0] = 1
# count modis snow, no snow pixels
count_modis_snow = (modis_bin == 1).sum()
count_modis_dry = (modis_bin == 0).sum()
# calculate weight
