def atLoc(mkNameFile,diction,inFol,outFol):
mkArray = funcs.singleTifToArray(mkNameFile)
outArray= np.zeros(mkArray.shape)
for key in diction:
dictVal = diction[key]
keyArray = funcs.singleTifToArray(inFol + str(key) + "_rval.tif")
condlist = [ mkArray == dictVal ]
choicelist = [ keyArray ]
outArray = np.select(condlist, choicelist, outArray)
funcs.array_to_raster(mkNameFile,outArray, outFol+"rval_MK_name_sig2.tif")
#VERY INEFFICIENT -> deprecated:
#iterate over the best_pix Names of Mann Kendall and extract the rvals... of this combination
#return as own raster
#mkNameFile is the Mann-Kendall file to iterate over, inFol contains the rval rasters,
# diction is a dictionary with short numbers as keys (the ones in mkNameFile)
# and long numbers as values
# noData is the value to be skipped as it does not indicate a real combination
python类select()的实例源码
def getLargVal(*inA):
inputlen = len(inA)
for i in range(inputlen):
if i == 0:
condlist = [ inA[0] > inA[1] ]
choicelist = [ inA[0] ]
result = np.select(condlist, choicelist, inA[1])
elif i == 1:
continue
else:
condlist = [ result > inA[i] ]
choicelist = [ result ]
result = np.select(condlist, choicelist, inA[i])
return result
#DEPRECATED: ONLY WORKS FOR UP TO 4 INPUT ARRAYS, OLD MANUAL WAY
def hsv_to_rgb(hsv):
""" Input HSV image [0~1] return RGB image [0~255].
Parameters
-------------
hsv : should be a numpy arrays with values between 0.0 and 1.0
"""
# Translated from source of colorsys.hsv_to_rgb
# h,s should be a numpy arrays with values between 0.0 and 1.0
# v should be a numpy array with values between 0.0 and 255.0
# hsv_to_rgb returns an array of uints between 0 and 255.
rgb = np.empty_like(hsv)
rgb[..., 3:] = hsv[..., 3:]
h, s, v = hsv[..., 0], hsv[..., 1], hsv[..., 2]
i = (h * 6.0).astype('uint8')
f = (h * 6.0) - i
p = v * (1.0 - s)
q = v * (1.0 - s * f)
t = v * (1.0 - s * (1.0 - f))
i = i % 6
conditions = [s == 0.0, i == 1, i == 2, i == 3, i == 4, i == 5]
rgb[..., 0] = np.select(conditions, [v, q, p, p, t, v], default=v)
rgb[..., 1] = np.select(conditions, [v, v, v, q, p, p], default=t)
rgb[..., 2] = np.select(conditions, [v, p, t, v, v, q], default=p)
return rgb.astype('uint8')
def process1(self, m79, hz):
if len(m79) < 79:
return
snr = self.snr(m79)
# convert to S/N. this seems to help, though I do not know why.
mm = numpy.median(m79, 1)
mm = numpy.select( [ mm > 0.000001 ], [ mm ], default=numpy.mean(mm))
sm = numpy.stack([mm,mm,mm,mm,mm,mm,mm,mm], 1)
m79 = numpy.divide(m79, sm)
[ winmean, winstd, losemean, losestd ] = self.softstats(m79)
dec = self.process2(m79, hz, snr, winmean, winstd, losemean, losestd)
return dec
def getLargVal_man(*inA):
inputlen = len(inA)
if inputlen == 2:
condlist = [ inA[0] > inA[1] ]
choicelist = [ inA[0] ]
result = np.select(condlist, choicelist, inA[1])
elif inputlen == 3:
condlist = [ np.logical_and(inA[0]>inA[1],inA[0]>inA[2]),
inA[1]>inA[2] ]
choicelist = [ inA[0], inA[1] ]
result = np.select(condlist, choicelist, inA[2])
elif inputlen == 4:
condlist = [ np.logical_and(inA[0]>inA[1],
np.logical_and(inA[0]>inA[2], inA[0]>inA[3])),
np.logical_and(inA[1]>inA[2], inA[1]>inA[3]),
inA[2]>inA[3] ]
choicelist = [ inA[0], inA[1], inA[2] ]
result = np.select(condlist, choicelist, inA[3])
else:
print("Only up to 4 arrays supported")
return result
#########################################################################################
#Array to Raster conversion, two ways
#########################################################################################
def rgb_to_hsv(rgb):
""" Input RGB image [0~255] return HSV image [0~1].
Parameters
-------------
rgb : should be a numpy arrays with values between 0 and 255.
"""
# Translated from source of colorsys.rgb_to_hsv
# r,g,b should be a numpy arrays with values between 0 and 255
# rgb_to_hsv returns an array of floats between 0.0 and 1.0.
rgb = rgb.astype('float')
hsv = np.zeros_like(rgb)
# in case an RGBA array was passed, just copy the A channel
hsv[..., 3:] = rgb[..., 3:]
r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
maxc = np.max(rgb[..., :3], axis=-1)
minc = np.min(rgb[..., :3], axis=-1)
hsv[..., 2] = maxc
mask = maxc != minc
hsv[mask, 1] = (maxc - minc)[mask] / maxc[mask]
rc = np.zeros_like(r)
gc = np.zeros_like(g)
bc = np.zeros_like(b)
rc[mask] = (maxc - r)[mask] / (maxc - minc)[mask]
gc[mask] = (maxc - g)[mask] / (maxc - minc)[mask]
bc[mask] = (maxc - b)[mask] / (maxc - minc)[mask]
hsv[..., 0] = np.select(
[r == maxc, g == maxc], [bc - gc, 2.0 + rc - bc], default=4.0 + gc - rc)
hsv[..., 0] = (hsv[..., 0] / 6.0) % 1.0
return hsv
def calc_correls(periods: ArrayLike, period_cond: float) -> np.ndarray:
"""Baker and Jayaram (2008, :cite:`baker08`) correlation model.
Parameters
----------
periods : array_like
Periods at which the correlation should be computed.
period_cond : float
Conditioning period
Returns
-------
correls : :class:`np.ndarray`
Correlation coefficients
"""
periods = np.asarray(periods)
periods_min = np.minimum(periods, period_cond)
periods_max = np.maximum(periods, period_cond)
c_1 = (1 - np.cos(np.pi / 2 - 0.366 * np.log(periods_max / np.maximum(
periods_min, 0.109))))
c_2 = np.select([periods_max < 0.2, True], [
1 - 0.105 * (1 - 1 / (1 + np.exp(100 * periods_max - 5))) *
(periods_max - periods_min) / (periods_max - 0.0099), 0
])
c_3 = np.select([periods_max < 0.109, True], [c_2, c_1])
c_4 = (c_1 + 0.5 * (np.sqrt(c_3) - c_3) *
(1 + np.cos(np.pi * periods_min / 0.109)))
correls = np.select(
[periods_max < 0.109, periods_min > 0.109, periods_max < 0.200, True],
[c_2, c_1, np.minimum(c_2, c_4), c_4], )
return correls
def forward(self, x):
self.x = x
self.y = np.select([x > 0], [x], 0)
return self.y
def backward(self, d):
return np.select([self.x > 0], [d], 0)
def squareFit(self,xReal,yReal):
N=len(xReal)
mx = yReal.max()
mn = yReal.min()
OFFSET = (mx+mn)/2.
amplitude = (np.average(yReal[yReal>OFFSET]) - np.average(yReal[yReal<OFFSET]) )/2.0
yTmp = np.select([yReal<OFFSET,yReal>OFFSET],[0,2])
bools = abs(np.diff(yTmp))>1
edges = xReal[bools]
levels = yTmp[bools]
frequency = 1./(edges[2]-edges[0])
phase=edges[0]#.5*np.pi*((yReal[0]-offset)/amplitude)
dc=0.5
if len(edges)>=4:
if levels[0]==0:
dc = (edges[1]-edges[0])/(edges[2]-edges[0])
else:
dc = (edges[2]-edges[1])/(edges[3]-edges[1])
phase = edges[1]
guess = [amplitude, frequency, phase,dc,0]
try:
(amplitude, frequency, phase,dc,offset), pcov = self.optimize.curve_fit(self.squareFunc, xReal, yReal-OFFSET, guess)
offset+=OFFSET
if(frequency<0):
#print ('negative frq')
return False
freq=1e6*abs(frequency)
amp=abs(amplitude)
pcov[0]*=1e6
#print (pcov)
if(abs(pcov[-1][0])>1e-6):
False
return [amp, freq, phase,dc,offset]
except:
return False
def squareFit(self,xReal,yReal):
N=len(xReal)
mx = yReal.max()
mn = yReal.min()
OFFSET = (mx+mn)/2.
amplitude = (np.average(yReal[yReal>OFFSET]) - np.average(yReal[yReal<OFFSET]) )/2.0
yTmp = np.select([yReal<OFFSET,yReal>OFFSET],[0,2])
bools = abs(np.diff(yTmp))>1
edges = xReal[bools]
levels = yTmp[bools]
frequency = 1./(edges[2]-edges[0])
phase=edges[0]#.5*np.pi*((yReal[0]-offset)/amplitude)
dc=0.5
if len(edges)>=4:
if levels[0]==0:
dc = (edges[1]-edges[0])/(edges[2]-edges[0])
else:
dc = (edges[2]-edges[1])/(edges[3]-edges[1])
phase = edges[1]
guess = [amplitude, frequency, phase,dc,0]
try:
(amplitude, frequency, phase,dc,offset), pcov = self.optimize.curve_fit(self.squareFunc, xReal, yReal-OFFSET, guess)
offset+=OFFSET
if(frequency<0):
#print ('negative frq')
return False
freq=1e6*abs(frequency)
amp=abs(amplitude)
pcov[0]*=1e6
#print (pcov)
if(abs(pcov[-1][0])>1e-6):
False
return [amp, freq, phase,dc,offset]
except:
return False