def Flood():
for y in xrange(2002, 2005):
lists = [[path+str(y) + "/flood_thr.%d%03d.tif" % (y, m) for m in xrange(91, 335)]]
array = np.array(lists)
images = array.reshape(array.shape[0] * array.shape[1])
n = 0
array = []
for j in images:
if os.path.exists(j) is True:
image = GImage(j)
flood = image.Band2Array(1)
if n ==0 :
flood = np.where(flood == fill, 0 , flood)
for k in xrange(len(flood)):
array.append(flood[k])
else:
array = np.where(flood == fill, add(array,0) , add(array, flood))
n += 1
print n
#tif_opath1= tifpath+str(y)+".totalevi.tif"
#image.WriteArrayAsImage(tif_opath1, array)
#array = array*8
tif_opath= path+str(y)+".flood_K_dur.tif"
image.WriteArrayAsImage(tif_opath, array)
print y
def CalcLSWI (self, NIR, SWIR, Blue, fill):
Blue [Blue >= 0.27] = fill
Swir_lower=numpy.where(Blue == fill, fill , add(NIR, SWIR))
Swir_upper=numpy.where(Blue == fill, fill , subtract(NIR, SWIR))
Swir_lower=numpy.where(Swir_lower ==0 , fill, Swir_lower)
LSWI=numpy.where(Swir_lower==fill, fill ,Swir_upper/Swir_lower)
return LSWI
def CalcNDVI ( self , NIR , Red, fill):
Ndvi_lower = numpy.where (NIR == fill, fill , add (NIR , Red))
Ndvi_upper = numpy.where (NIR == fill, fill ,subtract (NIR , Red))
#Mask = Numpy.Greater (Ndvi_lower, 0)
Ndvi_lower = numpy.where (Ndvi_lower == 0 , fill , Ndvi_lower)
NDVI = numpy.where (Ndvi_lower == fill , fill , Ndvi_upper/Ndvi_lower)
return NDVI
def _lerp(a, b, t, out=None):
""" Linearly interpolate from a to b by a factor of t """
diff_b_a = subtract(b, a)
# asanyarray is a stop-gap until gh-13105
lerp_interpolation = asanyarray(add(a, diff_b_a * t, out=out))
subtract(b, diff_b_a * (1 - t), out=lerp_interpolation, where=t >= 0.5)
if lerp_interpolation.ndim == 0 and out is None:
lerp_interpolation = lerp_interpolation[()] # unpack 0d arrays
return lerp_interpolation
def CalcMLSWI ( self , NIR , SWIR, fill):
mlswi_lower = numpy.where (NIR == fill, fill , add (NIR , SWIR))
mlswi_upper = numpy.where (NIR == fill, fill ,subtract (NIR , SWIR))
#Mask = Numpy.Greater (Ndvi_lower, 0)
mlswi_lower = numpy.where (mlswi_lower == 0 , fill , mlswi_lower)
lower = (1-mlswi_lower)
lower = numpy.where (lower == 0 , fill , lower)
mlswi = numpy.where (mlswi_lower == fill , fill , (1-mlswi_upper)/lower)
#mlswi1= numpy.where (((mlswi>= 0.75) & (mlswi <= 1.0)), 1, 0)
#MLSWI = numpy.where (NIR == fill , fill , mlswi1 )
return mlswi
fill = -999
def Flood():
for y in xrange(2000, 2015):
lists = [[path + "A%d%03d.flood.tif" % (y, m) for m in xrange(001, 362, 8)]]
array = np.array(lists)
images = array.reshape(array.shape[0] * array.shape[1])
n = 0
array = []
for j in images:
if os.path.exists(j) is True:
image = GImage(j)
flood = image.Band2Array(1)
if n ==0 :
flood = np.where(flood == fill, 0 , flood)
for k in xrange(len(flood)):
array.append(flood[k])
else:
array = np.where(flood == fill, add(array,0) , add(array, flood))
n += 1
print n
#tif_opath1= tifpath+str(y)+".totalevi.tif"
#image.WriteArrayAsImage(tif_opath1, array)
array = array*8
tif_opath= path+str(y)+".flood.tif"
image.WriteArrayAsImage(tif_opath, array)
print y
Flood()
def _var(a,
axis=None,
dtype=None,
out=None,
ddof=0,
keepdims=False,
*,
where=True):
arr = asanyarray(a)
rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where)
# Make this warning show up on top.
if ddof >= rcount if where is True else umr_any(ddof >= rcount, axis=None):
warnings.warn("Degrees of freedom <= 0 for slice",
RuntimeWarning,
stacklevel=2)
# Cast bool, unsigned int, and int to float64 by default
if dtype is None and issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
dtype = mu.dtype("f8")
# Compute the mean.
# Note that if dtype is not of inexact type then arraymean will
# not be either.
arrmean = umr_sum(arr, axis, dtype, keepdims=True, where=where)
# The shape of rcount has to match arrmean to not change the shape of out
# in broadcasting. Otherwise, it cannot be stored back to arrmean.
if rcount.ndim == 0:
# fast-path for default case when where is True
div = rcount
else:
# matching rcount to arrmean when where is specified as array
div = rcount.reshape(arrmean.shape)
if isinstance(arrmean, mu.ndarray):
arrmean = um.true_divide(arrmean,
div,
out=arrmean,
casting="unsafe",
subok=False)
else:
arrmean = arrmean.dtype.type(arrmean / rcount)
# Compute sum of squared deviations from mean
# Note that x may not be inexact and that we need it to be an array,
# not a scalar.
x = asanyarray(arr - arrmean)
if issubclass(arr.dtype.type, (nt.floating, nt.integer)):
x = um.multiply(x, x, out=x)
# Fast-paths for built-in complex types
elif x.dtype in _complex_to_float:
xv = x.view(dtype=(_complex_to_float[x.dtype], (2, )))
um.multiply(xv, xv, out=xv)
x = um.add(xv[..., 0], xv[..., 1], out=x.real).real
# Most general case; includes handling object arrays containing imaginary
# numbers and complex types with non-native byteorder
else:
x = um.multiply(x, um.conjugate(x), out=x).real
ret = umr_sum(x, axis, dtype, out, keepdims=keepdims, where=where)
# Compute degrees of freedom and make sure it is not negative.
rcount = um.maximum(rcount - ddof, 0)
# divide by degrees of freedom
if isinstance(ret, mu.ndarray):
ret = um.true_divide(ret,
rcount,
out=ret,
casting="unsafe",
subok=False)
elif hasattr(ret, "dtype"):
ret = ret.dtype.type(ret / rcount)
else:
ret = ret / rcount
return ret
fill = -999
def EVI():
for y in xrange(2000, 2011):
lists = [[tifpath + "A%d%03d.US.evi.tif" % (y, m) for m in xrange(001, 362, 8)]]
array = np.array(lists)
images = array.reshape(array.shape[0] * array.shape[1])
n = 0
array = []
for j in images:
if os.path.exists(j) is True:
image = GImage(j)
EVI = image.Band2Array(1)
if n ==0 :
EVI = np.where(EVI == fill, 0 , EVI)
for k in xrange(len(EVI)):
array.append(EVI[k])
else:
array = np.where(EVI == fill, add(array,0) , add(array, EVI))
n += 1
print n
#tif_opath1= tifpath+str(y)+".totalevi.tif"
#image.WriteArrayAsImage(tif_opath1, array)
array = array/n
tif_opath= tifpath+str(y)+".US.evi.tif"
image.WriteArrayAsImage(tif_opath, array)
print y
EVI()
def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
arr = asanyarray(a)
rcount = _count_reduce_items(arr, axis)
# Make this warning show up on top.
if ddof >= rcount:
warnings.warn("Degrees of freedom <= 0 for slice",
RuntimeWarning,
stacklevel=2)
# Cast bool, unsigned int, and int to float64 by default
if dtype is None and issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
dtype = mu.dtype('f8')
# Compute the mean.
# Note that if dtype is not of inexact type then arraymean will
# not be either.
arrmean = umr_sum(arr, axis, dtype, keepdims=True)
if isinstance(arrmean, mu.ndarray):
arrmean = um.true_divide(arrmean,
rcount,
out=arrmean,
casting='unsafe',
subok=False)
else:
arrmean = arrmean.dtype.type(arrmean / rcount)
# Compute sum of squared deviations from mean
# Note that x may not be inexact and that we need it to be an array,
# not a scalar.
x = asanyarray(arr - arrmean)
if issubclass(arr.dtype.type, (nt.floating, nt.integer)):
x = um.multiply(x, x, out=x)
# Fast-paths for built-in complex types
elif x.dtype in _complex_to_float:
xv = x.view(dtype=(_complex_to_float[x.dtype], (2, )))
um.multiply(xv, xv, out=xv)
x = um.add(xv[..., 0], xv[..., 1], out=x.real).real
# Most general case; includes handling object arrays containing imaginary
# numbers and complex types with non-native byteorder
else:
x = um.multiply(x, um.conjugate(x), out=x).real
ret = umr_sum(x, axis, dtype, out, keepdims)
# Compute degrees of freedom and make sure it is not negative.
rcount = max([rcount - ddof, 0])
# divide by degrees of freedom
if isinstance(ret, mu.ndarray):
ret = um.true_divide(ret,
rcount,
out=ret,
casting='unsafe',
subok=False)
elif hasattr(ret, 'dtype'):
ret = ret.dtype.type(ret / rcount)
else:
ret = ret / rcount
return ret
def CalcNDVI(self, NIR, Red):
ndvi_lower = add(NIR, Red)
ndvi_upper = subtract(NIR, Red)
NDVI = numpy.where(ndvi_lower == 0, 0.0, ndvi_upper/ndvi_lower)
return NDVI
