def addRBF(self, newXt, n=1000, qhull_opts="", output=True, makeHull=True):
sampled=False; x=1.0;i=0
while not(sampled):
diff=self.Xt-newXt
diff[:,2]*=self.vref*x
diff*=diff
diff=diff.sum(1)
diff=np.sqrt(diff)
index=np.argpartition(diff, n)[:n] #provide the indices of the n closest points
points=self.array[index,:]
rsampled=len(set(points[:,0]))>5
zsampled=len(set(points[:,1]))>5
tsampled=len(set(points[:,2]))>5
if rsampled and zsampled and tsampled:
sampled=True
elif not(rsampled and zsampled):
x*=2;i+=1
else:
x/=1.3;i+=1
if i>=100:
sampled=True
print "max iterations reached, forcing convergence"
if output: print("creating RBF at ", newXt)
def dist_func(X1,X2):
X=X1[:-1,...]-X2[:-1,...]
T=(X1[-1,...]-X2[-1,...])*self.vref
return np.sqrt((X**2).sum(0)+T**2)
RBFu=Rbf(points[:,0], points[:,1], points[:,2], points[:,3],\
norm=dist_func, smooth=0, epsilon=5e2)
RBFw=Rbf(points[:,0], points[:,1], points[:,2], points[:,4],\
norm=dist_func, smooth=0, epsilon=5e2)
if makeHull:
hull=Delaunay(RBFu.xi.T, qhull_options="QJ10000 "+qhull_opts) #creates a convex hull around the points used to construct the RBF
RBFu.hull=hull #a point cant be tested to be interior to the hull with:
RBFw.hull=hull #RBF.hull.find_simplex([r,z,t])>=0
RBFu.centre=points.mean(0)
RBFw.centre=points.mean(0)
self.RBFs.appendleft([RBFu, RBFw])
def run(self):
while not self.kill_received:
# get a task
try:
y_range, x_range, back_size = self.work_queue.get_nowait()
except Queue.Empty:
break
# the actual processing
print 'Worker running: ', multiprocessing.current_process()
# print "Computing the sky - XRANGE=", y_range, " - YRANGE=", x_range
im_size = np.asarray(shared_im.shape)
im_pad = back_size
y_pad = [
0 if y_range[0] == 0 else -im_pad[0],
0 if y_range[1] == (im_size[0] - 1) else im_pad[0]
]
x_pad = [
0 if x_range[0] == 0 else -im_pad[1],
0 if x_range[1] == (im_size[1] - 1) else im_pad[1]
]
im_data = shared_im[y_range[0] + y_pad[0]:y_range[1] + y_pad[1],
x_range[0] + x_pad[0]:x_range[1] + x_pad[1]]
yextra = im_data.shape[0] % back_size[0]
xextra = im_data.shape[1] % back_size[1]
ypad, xpad = 0, 0
if yextra > 0: ypad = back_size[0] - yextra
if xextra > 0: xpad = back_size[1] - xextra
pad_width = ((0, ypad), (0, xpad))
im_data_pad = np.pad(im_data,
pad_width,
mode='constant',
constant_values=[np.nan])
ny, nx = im_data_pad.shape
ny_box, nx_box = back_size
y_nbins = int(ny /
ny_box) # always integer because data were padded
x_nbins = int(nx /
nx_box) # always integer because data were padded
im_data_rebin = np.swapaxes(
im_data_pad.reshape(y_nbins, ny_box, x_nbins, nx_box), 1,
2).reshape(y_nbins, x_nbins, ny_box * nx_box)
grid_data = np.median(im_data_rebin, axis=2)
grid_x, grid_y = np.meshgrid(
np.arange(back_size[0] / 2, nx, back_size[0]),
np.arange(back_size[1] / 2, ny, back_size[1]))
grid_gv = np.isfinite(grid_data)
im_x, im_y = np.meshgrid(np.arange(0, nx), np.arange(0, ny))
print "y_nbins, x_nsbins = ", y_nbins, x_nbins
print "Shape of grid_x ", grid_x.shape
print "Shape of im_x ", im_x.shape
print np.sum(grid_gv)
# im_data_inter= scipy.interpolate.griddata((grid_y[grid_gv].flatten(),grid_x[grid_gv].flatten()), grid_data[grid_gv].flatten() , (im_y, im_x),method='cubic')
if np.sum(grid_gv) > 2:
im_rbf = Rbf(grid_y[grid_gv],
grid_x[grid_gv],
grid_data[grid_gv],
function='thin_plate',
smooth=0.0)
im_data_inter = im_rbf(im_y, im_x)
shared_nim[y_range[0]:y_range[1],
x_range[0]:x_range[1]] = im_data_inter[
-y_pad[0]:y_range[1] - y_range[0] - y_pad[0],
-x_pad[0]:x_range[1] - x_range[0] - x_pad[0]]
# print "Shape of original image ", im_data.shape
# print "Shape of padded image ", im_data_pad.shape
# print "Shape of interpolated image ", im_data_inter.shape
# print "Range of shared_nim y_range=", y_range[0], y_range[1], " x_range=", x_range[0], x_range[1]
# print "Range of im_data_inter y_range=", -y_pad[0], y_range[1]-y_range[0]-y_pad[0], " x_range=", -y_pad[0], y_range[1]-y_range[0]-y_pad[0]
print 'Worker done: ', multiprocessing.current_process()
self.result_queue.put(id)
import matplotlib.pyplot as plt
import numpy as np
import scipy as sp #debemos de importar scipy
from scipy.interpolate import Rbf
x = np.random.rand(5)
y = np.random.rand(5)
pet = 2+2*np.random.rand(5)
rbfi =Rbf(x, y, pet)
xi = np.linspace(0,1)
yi = np.linspace(0,1)
XI, YI = np.meshgrid(xi,yi) # gridded locations
di = rbfi(XI, YI) # interpolated values
plt.imshow(di, extent=(0,1,0,1), origin='lower')
plt.scatter(x,y, color='k')
plt.xlabel('X')
plt.ylabel('Y')
plt.axis((0,1,0,1))
plt.savefig('rbf.png')
import numpy as np
from scipy.interpolate import Rbf
import matplotlib.pyplot as plt
from matplotlib import cm
import mpl_toolkits.mplot3d
PLOT3D = False
mu1 = [1, 0] # mean of rbf 1 (red) -> (w[0])
mu2 = [-1, 0] # mean of rbf 2 (blue) -> (w[1])
w = np.array([10, -10]) # weight vector
stddev = 1
ti = np.linspace(-2.0, 2.0, 100)
xx, yy = np.meshgrid(ti, ti)
rbf1 = Rbf(mu1[0], mu1[1], 1, epsilon=stddev, function='gaussian')
rbf2 = Rbf(mu2[0], mu2[1], 1, epsilon=stddev, function='gaussian')
phi = np.stack([rbf1(xx, yy), rbf2(xx, yy)]) # create featuremap tensor
X, Y, Z = xx, yy, np.tensordot(w, phi, axes=1) # calculate costfield
if not PLOT3D:
plt.xlabel('x')
plt.ylabel('y')
plt.pcolor(X, Y, Z, cmap=cm.jet)
plt.plot(mu1[0], mu1[1], 'o', ms=10, color='r')
plt.plot(mu2[0], mu2[1], 'o', ms=10, color='b')
plt.colorbar()
else:
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(
lats_orig, lons_orig = extractPositions(images)
doses_wrapped, lats_wrapped, lons_wrapped = wrapAround(doses, lats_orig,
lons_orig)
doses_log_wrapped, lats_wrapped, lons_wrapped = wrapAround(
doses_log, lats_orig, lons_orig)
#{ RBF interpolation
# create meshgrid for RBF
x_meshgrid, y_meshgrid = createMeshGrid(150)
# calculate RBF from log data
rbf_lin = Rbf(lats_wrapped,
lons_wrapped,
doses_wrapped,
function='multiquadric',
epsilon=1,
smooth=1)
doses_rbf_lin = rbf_lin(x_meshgrid, y_meshgrid)
# calculate RBF from lin data
rbf_log = Rbf(lats_wrapped,
lons_wrapped,
doses_log_wrapped,
function='multiquadric',
epsilon=1,
smooth=1)
doses_rbf_log = rbf_log(x_meshgrid, y_meshgrid)
#} end of RBF interpolation
def forecast(timeSeries, waveletStr, predictMonths, plotGraphs=True):
tsLength = len(timeSeries)
wavelet = pywt.Wavelet(waveletStr)
cA5, cD5, cD4, cD3, cD2, cD1 = pywt.wavedec(timeSeries, wavelet, level=5)
predict = [
predictMonths, predictMonths / 2, predictMonths / 4, predictMonths / 8,
predictMonths / 16, predictMonths / 32
]
# <codecell>
if plotGraphs:
print cA5.shape
print cD5.shape
print cD4.shape
print cD3.shape
print cD2.shape
print cD1.shape
# <codecell>
rcParams['figure.figsize'] = 7, 4
plt.plot(cA5)
plt.show()
# <codecell>
plt.plot(cD5)
plt.show()
# <codecell>
plt.plot(cD4)
plt.show()
# <codecell>
plt.plot(cD3)
plt.show()
# <codecell>
plt.plot(cD2)
plt.show()
# <codecell>
plt.plot(cD1)
plt.show()
# <headingcell level=2>
# Forecasting
# <rawcell>
# Extend the samples of cA5 using an interpolated univariate spline. This, by fitting this spline, we extended the
# data to values [0:349] rather than [0:336]. Wavelet reconstruct the signal using the interpolated approx
# <codecell>
# Sample extension using RBF method. Wavelet reconstruct the signal using the interpolated approx
t0 = np.linspace(0, tsLength - 1, cA5.shape[0]).astype(int)
if (predict[4] > 0):
ius_cA5 = InterpolatedUnivariateSpline(t0[:-predict[4]],
cA5[:-predict[4]])
rbf_cA5 = Rbf(t0[:-predict[4]], cA5[:-predict[4]])
else:
ius_cA5 = InterpolatedUnivariateSpline(t0, cA5)
rbf_cA5 = Rbf(t0, cA5)
ti = np.linspace(0, tsLength - 1, cA5.shape[0]).astype(int)
cA5i1 = ius_cA5(ti)
datai1 = pywt.waverec([cA5i1, cD5, cD4, cD3, cD2, cD1], waveletStr)
cA5i2 = rbf_cA5(ti)
datai2 = pywt.waverec([cA5i2, cD5, cD4, cD3, cD2, cD1], waveletStr)
# <rawcell>
# Comparison of the forecast based only on extrapolation of approximate wavelet decomposition part (IUS and RBF) with the true data
# <codecell>
if plotGraphs:
rcParams['figure.figsize'] = 18, 10
p1, = plot(timeSeries[tsLength - predictMonths - 20:], 'r')
p2, = plot(datai1[tsLength - predictMonths - 20:], 'b')
p3, = plot(datai2[tsLength - predictMonths - 20:], 'g')
p4, = plot(data[tsLength - predictMonths - 20:, 1], 'y')
legend([p3, p2, p1], ["RBF method", "Univariate Spline", "Oil Price"])
plt.show()
# <rawcell>
# We are going to model the detail part of the wavelet decomposition using a trigonometric fitting/sine fitting. So, first we get the Fourier transform of each of these waveforms
# <codecell>
if plotGraphs:
rcParams['figure.figsize'] = 7, 4
Cd1 = np.fft.fft(cD1)
plot(abs(Cd1))
plt.show()
# <codecell>
Cd2 = np.fft.fft(cD2)
plot(abs(Cd2))
plt.show()
# <codecell>
Cd3 = np.fft.fft(cD3)
plot(abs(Cd3))
plt.show()
# <codecell>
Cd4 = np.fft.fft(cD4)
plot(abs(Cd4))
plt.show()
# <codecell>
Cd5 = np.fft.fft(cD5)
plot(abs(Cd5))
plt.show()
# <codecell>
def mysine(x, a1, a2, a3):
return a1 * np.sin(a2 * x + a3)
def sinefit(yReal, xReal):
yhat = fftpack.rfft(yReal)
idx = (yhat**2).argmax()
freqs = fftpack.rfftfreq(len(xReal),
d=(xReal[1] - xReal[0]) / (2 * pi))
frequency = freqs[idx]
amplitude = abs(yReal.max())
guess = [amplitude, frequency, 0.]
(amplitude, frequency,
phase), pcov = optimize.curve_fit(mysine, xReal, yReal, guess)
period = 2 * pi / frequency
return [amplitude, frequency, phase]
testSig = mysine(np.linspace(0, 10, 5000), 2, 200, 56)
params = sinefit(testSig, np.linspace(0, 10, 5000))
if plotGraphs:
print params
# <codecell>
if predict[4] > 0:
paramsD5 = sinefit(
cD5[:-predict[4]],
np.linspace(0, tsLength, cD5.shape[0])[:-predict[4]])
cD5i = np.append(
cD5[:-predict[4]],
mysine(
np.linspace(cD5.shape[0] - predict[4], cD5.shape[0],
predict[4]), paramsD5[0], paramsD5[1],
paramsD5[2]))
else:
paramsD5 = sinefit(cD5, np.linspace(0, tsLength, cD5.shape[0]))
cD5i = np.append(
cD5,
mysine(np.linspace(cD5.shape[0], cD5.shape[0], 0), paramsD5[0],
paramsD5[1], paramsD5[2]))
if predict[3] > 0:
paramsD4 = sinefit(
cD4[:-predict[3]],
np.linspace(0, tsLength, cD4.shape[0])[:-predict[3]])
cD4i = np.append(
cD4[:-predict[3]],
mysine(
np.linspace(cD4.shape[0] - predict[3], cD4.shape[0],
predict[3]), paramsD4[0], paramsD4[1],
paramsD4[2]))
else:
paramsD4 = sinefit(cD4, np.linspace(0, tsLength, cD4.shape[0]))
cD4i = np.append(
cD4,
mysine(np.linspace(cD4.shape[0], cD4.shape[0], 0), paramsD4[0],
paramsD4[1], paramsD4[2]))
if predict[2] > 0:
paramsD3 = sinefit(
cD3[:-predict[2]],
np.linspace(0, tsLength, cD3.shape[0])[:-predict[2]])
cD3i = np.append(
cD3[:-predict[2]],
mysine(
np.linspace(cD3.shape[0] - predict[2], cD3.shape[0],
predict[2]), paramsD3[0], paramsD3[1],
paramsD3[2]))
else:
paramsD3 = sinefit(cD3, np.linspace(0, tsLength, cD3.shape[0]))
cD3i = np.append(
cD3,
mysine(np.linspace(cD3.shape[0], cD3.shape[0], 0), paramsD3[0],
paramsD3[1], paramsD3[2]))
if predict[1] > 0:
paramsD2 = sinefit(
cD2[:-predict[1]],
np.linspace(0, tsLength, cD2.shape[0])[:-predict[1]])
cD2i = np.append(
cD2[:-predict[1]],
mysine(
np.linspace(cD2.shape[0] - predict[1], cD2.shape[0],
predict[1]), paramsD2[0], paramsD2[1],
paramsD2[2]))
else:
paramsD2 = sinefit(cD2, np.linspace(0, tsLength, cD2.shape[0]))
cD2i = np.append(
cD2,
mysine(np.linspace(cD2.shape[0], cD2.shape[0], 0), paramsD2[0],
paramsD2[1], paramsD2[2]))
if predict[0] > 0:
paramsD1 = sinefit(
cD1[:-predict[0]],
np.linspace(0, tsLength, cD1.shape[0])[:-predict[0]])
cD1i = np.append(
cD1[:-predict[0]],
mysine(
np.linspace(cD1.shape[0] - predict[0], cD1.shape[0],
predict[0]), paramsD1[0], paramsD1[1],
paramsD1[2]))
else:
paramsD1 = sinefit(cD1, np.linspace(0, tsLength, cD1.shape[0]))
cD1i = np.append(
cD1,
mysine(np.linspace(cD1.shape[0], cD1.shape[0], 0), paramsD1[0],
paramsD1[1], paramsD1[2]))
datai1 = pywt.waverec([cA5i1, cD5i, cD4i, cD3i, cD2i, cD1i], waveletStr)
datai2 = pywt.waverec([cA5i2, cD5i, cD4i, cD3i, cD2i, cD1i], waveletStr)
# <headingcell level=2>
# Forecast using all the interpolated signals
# <codecell>
if plotGraphs:
rcParams['figure.figsize'] = 18, 10
p1, = plot(timeSeries[tsLength - predictMonths - 20:], 'r')
p2, = plot(datai1[tsLength - predictMonths - 20:], 'b')
p3, = plot(datai2[tsLength - predictMonths - 20:], 'g')
p4, = plot(data[tsLength - predictMonths - 20:, 1], 'y')
legend([p4, p3, p2, p1],
["Contract 1", "RBF method", "Univariate Spline", "Oil Price"])
plt.show()
return datai2
def interpolate(x,
y,
data,
grid_xy=None,
interp_type='linear',
hres=50000,
minimum_neighbors=3,
num_pass=1,
gamma=0.25,
kappa_star=5.052,
search_radius=None,
rbf_func='linear',
rbf_smooth=0,
op_param=None,
comp_err=0):
r"""Interpolate given (x,y), observation (z) pairs to a grid based on given parameters.
Parameters
----------
x: array_like
x coordinate
y: array_like
y coordinate
data: array_like
observation value
grid_xy: (grid_x, grid_y) tuple of (N, 2) ndarrays
Meshgrid for the resulting interpolation in the x and y dimension respectively
Default None (calculated from x and y)
interp_type: str
What type of interpolation to use. Available options include:
1) "linear", "nearest", "cubic", or "rbf" from Scipy.interpolate.
2) "natural_neighbor", "barnes", or "cressman" from Metpy.mapping .
Default "linear".
hres: float
The horizontal resolution of the generated grid. Default 50000 meters.
min_neighbors: int
Minimum number of neighbors needed to perform barnes or cressman interpolation for a
point. Default is 3.
gamma: float
Adjustable smoothing parameter for the barnes interpolation. Default 0.25.
kappa_star: float
Response parameter for barnes interpolation, specified nondimensionally
in terms of the Nyquist. Default 5.052
search_radius: float
A search radius to use for the barnes and cressman interpolation schemes.
If search_radius is not specified, it will default to the average spacing of
observations.
rbf_func: str
Specifies which function to use for Rbf interpolation.
Options include: 'multiquadric', 'inverse', 'gaussian', 'linear', 'cubic',
'quintic', and 'thin_plate'. Defualt 'linear'. See scipy.interpolate.Rbf for more
information.
rbf_smooth: float
Smoothing value applied to rbf interpolation. Higher values result in more smoothing.
Returns
-------
grid_xy: tuple of two (N, 2) ndarrays
Meshgrid for the resulting interpolation in the x and y dimensions respectively
img: (M, N) ndarray
2-dimensional array representing the interpolated values for each grid.
"""
# set up resulting grid
if grid_xy is None:
grid_x, grid_y = intp.points.generate_grid(
hres, intp.points.get_boundary_coords(x, y))
else:
if len(grid_xy) != 2:
raise ValueError("when specified, grid_xy must have 2 elements")
else:
grid_x, grid_y = grid_xy
if grid_x.shape != grid_y.shape:
raise ValueError("grid_x and grid_y must have the same shape")
# interpolate
if interp_type in ['linear', 'nearest', 'cubic']:
points_zip = np.array(list(zip(x, y)))
img = griddata(points_zip, data, (grid_x, grid_y), method=interp_type)
elif interp_type == 'natural_neighbor':
img = intp.natural_neighbor(x, y, data, grid_x, grid_y)
elif interp_type in ['cressman', 'barnes', 'bratseth']:
if interp_type == 'cressman':
img = intp.inverse_distance(x,
y,
data,
grid_x,
grid_y,
search_radius,
minimum_neighbors,
kind=interp_type)
elif interp_type == 'barnes':
ave_spacing = np.mean((cdist(list(zip(x, y)), list(zip(x, y)))))
kappa = intp.calc_kappa(ave_spacing, kappa_star)
img = intp.inverse_distance(x,
y,
data,
grid_x,
grid_y,
search_radius,
minimum_neighbors,
gamma=gamma,
kappa=kappa,
num_pass=num_pass,
kind=interp_type)
elif interp_type == 'rbf':
# 3-dimensional support not yet included.
# Assign a zero to each z dimension for observations.
h = np.zeros((len(x)))
rbfi = Rbf(x, y, h, data, function=rbf_func, smooth=rbf_smooth)
# 3-dimensional support not yet included.
# Assign a zero to each z dimension grid cell position.
hi = np.zeros(grid_x.shape)
img = rbfi(grid_x, grid_y, hi)
elif interp_type == 'optimal':
grid_points = intp.points.generate_grid_coords(grid_x, grid_y)
if op_param == None:
raise ValueError(
'Parameters must be set as input with argument op_param=:')
elif np.size(op_param) != 4:
raise ValueError('Argument op_param most be length 4')
else:
parameters = np.concatenate((op_param, [data.max()], [data.min()]))
#else: Interpolate with user specified parameters ...
args, spect_err = intp.optimal_parameters(x,
y,
data,
grid_points,
parameters,
comp_err=comp_err)
img = intp.optimal_interp(args).reshape(grid_x.shape)
if comp_err == 1:
spect_err = spect_err.reshape(grid_x.shape)
else:
raise ValueError(
'Interpolation option not available. '
'Try: linear, nearest, cubic, natural_neighbor, '
'optimal', 'barnes, cressman, rbf')
if grid_xy == None:
return (grid_x, grid_y), img
else:
if comp_err:
return img, spect_err
else:
return img
d2_doses_subset_log, d2_subset_lats, d2_subset_lons)
d4_doses_subset_log_wrapped, d4_subset_lats_wrapped, d4_subset_lons_wrapped = wrapAround(
d4_doses_subset_log, d4_subset_lats, d4_subset_lons)
d2_doses_log_wrapped, d2_lats_wrapped, d2_lons_wrapped = wrapAround(
d2_doses_log, d2_lats_original, d2_lons_original)
d4_doses_log_wrapped, d4_lats_wrapped, d4_lons_wrapped = wrapAround(
d4_doses_log, d4_lats_original, d4_lons_original)
# create meshgrid for RBF
x_meshgrid, y_meshgrid = createMeshGrid(100)
# calculate RBF from lin data
d2_subset_rbf_log = Rbf(d2_subset_lats_wrapped,
d2_subset_lons_wrapped,
d2_doses_subset_log_wrapped,
function='multiquadric',
epsilon=0.1,
smooth=0.1)
d2_subset_doses_rbf_log = d2_subset_rbf_log(x_meshgrid, y_meshgrid)
d2_rbf_log = Rbf(d2_lats_wrapped,
d2_lons_wrapped,
d2_doses_log_wrapped,
function='multiquadric',
epsilon=0.1,
smooth=0.1)
d2_doses_rbf_log = d2_rbf_log(x_meshgrid, y_meshgrid)
d4_subset_rbf_log = Rbf(d4_subset_lats_wrapped,
d4_subset_lons_wrapped,
d4_doses_subset_log_wrapped,
def scale_spectra(common_text, list_photfiles, prefix_str='f', plot=False):
"""
Scales spectra acccording to the values in the array 'scale_array'. Basically, this step applies
flux calibration on the spectra.
Args:
common_text : Common text of 1-D Spectra files whose spectroscopic fluxes are to be scaled
list_photfiles : Text list of files containing different broadband photometric magnitudes
prefix_str : Prefix to distinguish the scaled 1-D spectra from the original
plot : Boolean describing whether the scaled spectra has to be plotted
Returns:
None
"""
list_files = group_similar_files('', common_text=common_text)
for file_name in list_files:
dict_spec = read_specflux(file_name)
dict_phot = read_photflux(list_photfiles=list_photfiles,
julian_day=read_jd(file_name))
dict_phot = get_zflux(dict_phot, cntrl_wav=7500)
dict_scale = dict(
(key, str(float(dict_phot[key]) / float(dict_spec[key])))
for key in dict_phot.keys() if key in dict_spec.keys())
if len(dict_scale.keys()) > 3:
del dict_scale[7500]
# if len(dict_scale.keys()) > 4:
# order = 4
# else:
# order = len(dict_scale.keys()) - 1
series = pd.Series(dict_scale, dtype='float64')
spline = CubicSpline(series.index.values,
series.values,
bc_type='natural',
extrapolate=True)
spline2 = Rbf(series.index.values, series.values)
wave_data, flux_data = read_1dspec(file_name)
scale_data = spline(wave_data)
scale_data[scale_data < 0] = 0
flux_moddata = np.multiply(np.asarray(flux_data), scale_data)
write_1dspec(ref_filename=file_name,
flux_array=flux_moddata,
prefix_str=prefix_str)
if plot:
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
wavenew = np.linspace(float(wave_data[0]), float(wave_data[-1]),
10000)
ax.plot(series.index.values,
series.values,
'o',
label='Data Points')
ax.plot(wavenew, spline(wavenew), 'k', label='CubicSpline')
ax.plot(wavenew, spline2(wavenew), 'r', label='Rbf')
ax.legend()
ax.grid()
plt.show()
plt.close(fig)
groups = warp.split()
list_old_x, list_old_y, list_new_x, list_new_y, list_old_dist, list_new_dist = (
[] for i in range(6))
for group in groups:
coords = group.split(',')
list_old_x.append(float(coords[0]))
list_old_y.append(float(coords[1]))
list_new_x.append(float(coords[2]))
list_new_y.append(float(coords[3]) + random.random() / 1000000)
list_old_dist.append(dist(list_old_x[-1], list_old_y[-1], 0.5, 0.5))
list_new_dist.append(dist(list_new_x[-1], list_new_y[-1], 0.5, 0.5))
interpType = 'linear'
interpFunctionOldDist = Rbf(list_new_x,
list_new_y,
list_old_dist,
function=interpType)
interpFunctionNewDist = Rbf(list_old_x,
list_old_y,
list_new_dist,
function=interpType)
ringDist = oneMinuteDistance * ringMinutes
frameCount = 0
pTimeProgress = 0
numRows = mapResolution * len(framesToRender)
rowsDone = 0
startTime = datetime.now()
for frameNumber in framesToRender:
progress = float(frameNumber) / frames
df_ori = df_mid.copy().sample(frac=0.05,
random_state=1).reset_index(drop=True)
df_mid = df_mid.sample(frac=0.05,
random_state=constant).reset_index(drop=True)
df_test = df_mid[0:int(0.1 * df_mid.shape[0])]
df_train = df_mid[int(0.1 * df_mid.shape[0]):]
a, b, c, d, e, vals = df_train.to_numpy().T
now = time.time()
try:
W = joblib.load("weight_linear.pickle")
except:
rbfi = Rbf(a, b, c, d, e, vals, function="thin_plate")
print("Training time -----------------------> %s seconds" %
(time.time() - now))
print("ATTRIBUTES RBF")
print(rbfi.nodes)
joblib.dump(rbfi.nodes, "weight_linear.pickle", protocol=2)
W = rbfi.nodes
a_test, b_test, c_test, d_test, e_test = df_ori[
df_ori.columns[0:5]].to_numpy().T
X_train = df_train[df_train.columns[0:5]].to_numpy()
def plot_heatmap(
env_name: str,
algo_name: str,
param_names: List,
env_pairs_pass_probabilities: List[Tuple[Tuple, float]],
first_param_limits: List[float],
second_param_limits: List[float],
plot_points: bool = False,
save_plot: bool = False,
show_plot: bool = False,
file_path: str = None,
interpolation_function: str = "linear",
smooth: float = 0.0,
) -> float:
assert interpolation_function in [
"multiquadric",
"inverse",
"gaussian",
"linear",
"cubic",
"quintic",
"thin_plate",
], "interpolation_function should have one of these values: {}".format(
["multiquadric", "inverse", "gaussian", "linear", "cubic", "quintic", "thin_plate"]
)
dist = None
first_param_values = []
second_param_values = []
pass_probabilities = []
for env_pair_pass_probability in env_pairs_pass_probabilities:
mutated_pair = env_pair_pass_probability[0]
pass_probability = env_pair_pass_probability[1]
first_param_values.append(round(mutated_pair[0], 1))
second_param_values.append(round(mutated_pair[1], 1))
pass_probabilities.append(pass_probability)
dict_for_df = {
param_names[0]: first_param_values,
param_names[1]: second_param_values,
"pass_probability": pass_probabilities,
}
df = pd.DataFrame(dict_for_df)
heatmap_data = pd.pivot_table(df, values="pass_probability", index=[param_names[1]], columns=param_names[0])
first_param = Param(
**load_env_params(algo_name=algo_name, env_name=env_name, param_name=param_names[0]), id=0, name=param_names[0]
)
second_param = Param(
**load_env_params(algo_name=algo_name, env_name=env_name, param_name=param_names[1]), id=1, name=param_names[1]
)
min_first_param = first_param_limits[0] if len(first_param_limits) == 2 else first_param.get_low_limit()
max_first_param = first_param_limits[1] if len(first_param_limits) == 2 else first_param.get_high_limit()
min_second_param = second_param_limits[0] if len(second_param_limits) == 2 else second_param.get_low_limit()
max_second_param = second_param_limits[1] if len(second_param_limits) == 2 else second_param.get_high_limit()
extent = [min_first_param, max_first_param, min_second_param, max_second_param]
# Create regular grid
xi, yi = (
np.linspace(min_first_param, max_first_param, heatmap_data.shape[1]),
np.linspace(min_first_param, max_second_param, heatmap_data.shape[0]),
)
xi, yi = np.meshgrid(xi, yi)
# Interpolate missing data
matrix_is_singular_error = True
while matrix_is_singular_error:
try:
rbf = Rbf(
first_param_values, second_param_values, pass_probabilities, function=interpolation_function, smooth=smooth
)
matrix_is_singular_error = False
except LinAlgError:
smooth += 0.1
print("Matrix is singular: increasing smooth value to", smooth)
matrix_is_singular_error = True
zi = rbf(xi, yi)
if zi.shape == heatmap_data.shape:
dist = 1 / (1 + np.linalg.norm(zi - heatmap_data.values))
if show_plot or save_plot:
fig = plt.figure()
fig.suptitle(env_name + ", " + algo_name)
ax1 = fig.add_subplot(211)
cmap = LinearSegmentedColormap.from_list(name="test", colors=["red", "gold", "green"])
sns.heatmap(data=heatmap_data, cmap=cmap, linewidths=0.3, cbar_kws={"label": "Pass probability"})
ax1.invert_yaxis()
ax2 = fig.add_subplot(212)
hm = ax2.imshow(zi, interpolation="none", cmap=cmap, extent=extent, origin="lower", aspect="auto", vmin=0.0, vmax=1.0)
if plot_points:
ax2.scatter(first_param_values, second_param_values)
cbar = fig.colorbar(hm, ax=ax2)
cbar.ax.set_ylabel("Pass probability")
ax2.set_xlabel(param_names[0])
ax2.set_ylabel(param_names[1])
fig = plt.gcf()
fig.set_size_inches(12, 9)
if show_plot:
plt.show()
if save_plot:
if file_path:
plt.savefig(file_path, format="pdf")
else:
abs_prefix = os.path.abspath("../")
file_prefix = 0
file_suffix = "heatmap_" + interpolation_function + "_" + env_name + "_" + algo_name + "_"
file_name = file_suffix + str(file_prefix) + ".pdf"
while os.path.exists(os.path.join(abs_prefix, file_name)):
file_prefix += 1
file_name = file_suffix + str(file_prefix) + ".pdf"
plt.savefig(os.path.join(abs_prefix, file_name), format="pdf")
return dist
def plot_HK_map(flder='.',
lonrange=[120., 125.],
latrange=[-34., -30.],
info_file='/home/christian/info_file',
z='H',
gravity=False,
smooth=0.1,
eps=0.33,
Ps=False,
pval=False,
save=False,
mode='color'):
"""
plots an interpolated map of crustal thickness (or vp/vs) from a bunch of HK-stacking derived values
Ps=True only works with z='H'
mode = 'color' or 'contour' or 'both' (the last only works if gravity=False)
"""
# get dictionary, pick maxima from matrices
if Ps:
# read values from file, multiply with 8
xvals = []
yvals = []
zvals = []
if pval:
infile = open('all_checked', 'r')
else:
infile = open('Ps_all', 'r')
dtt = infile.readlines()
infile.close()
for j in dtt:
if pval:
sta, stat_lat, stat_lon, H, K, dum = j.strip('\n').split(None)
print(sta)
else:
sta, Ps = j.strip('\n').split(None)
# stat_lat,stat_lon,stat_elev = util.get_stat_coords(sta,info_file)
if float(stat_lat) >= latrange[0] and float(stat_lat) <= latrange[
1] and float(stat_lon) >= lonrange[0] and float(
stat_lon) <= lonrange[1]:
if z == 'K' and K == '----':
continue
xvals.append(float(stat_lon))
yvals.append(float(stat_lat))
if pval:
if z == 'H':
zvals.append(float(H))
elif z == 'K':
zvals.append(float(K))
else:
zvals.append(float(Ps) * 8)
else:
dic = dict_setup(flder=flder)
dic_picked = pick_max(dic)
# pkl.dump(dic_picked,open('storage_dic','wb'))
# dic_picked = pkl.load(open('storage_dic','rb'))
# now station-wise...get coordinates, store in 4-tuples (lat,lon,H,K)
xvals = []
yvals = []
zvals = []
for stat in dic_picked.keys():
lat, lon, elev = util_c_sippl.get_stat_coords(stat, info_file)
H = dic_picked[stat]['header']['max_HK'][0][1]
K = dic_picked[stat]['header']['max_HK'][0][0]
if float(lat) >= latrange[0] and float(lat) <= latrange[1] and float(lon) >= lonrange[0] and float(lon) <= \
lonrange[1]:
xvals.append(lon)
yvals.append(lat)
if z == 'H':
zvals.append(H)
elif z == 'K':
zvals.append(K)
# set control nodes (at 40 km)
for x in np.arange(lonrange[0], lonrange[1], 0.25):
for y in [latrange[0] - 0.25, latrange[1] + 0.25]:
xvals.append(x)
yvals.append(y)
if z == 'H':
zvals.append(37.5)
elif z == 'K':
zvals.append(1.73)
for y in np.arange(latrange[0], latrange[1], 0.25):
for x in [lonrange[0] - 0.25, lonrange[1] + 0.25]:
xvals.append(x)
yvals.append(y)
if z == 'H':
zvals.append(37.5)
elif z == 'K':
zvals.append(1.73)
print(xvals, yvals)
yi = np.linspace(latrange[0], latrange[1], 500)
xi = np.linspace(lonrange[0], lonrange[1], 500)
XI, YI = np.meshgrid(xi, yi)
from mpl_toolkits import basemap
plt.figure(figsize=(12, 12))
m = basemap.Basemap(projection='merc',
llcrnrlon=lonrange[0],
llcrnrlat=latrange[0],
urcrnrlon=lonrange[1],
urcrnrlat=latrange[1],
resolution='h')
XImap, YImap = m(XI, YI)
from scipy.interpolate import Rbf
xvals_map, yvals_map = m(xvals, yvals)
rbf = Rbf(xvals, yvals, zvals, epsilon=eps, smooth=smooth)
# rbf = Rbf(xvals_map,yvals_map,zvals)
ZI = rbf(XI, YI)
outfile = open('Moho_lowres.txt', 'w')
for i in range(len(ZI)):
for j in range(len(ZI[0])):
outfile.write(
str(round(XI[i][j], 3)) + ' ' + str(round(YI[i][j], 3)) + ' ' +
str(round(ZI[i][j], 3)) + '\n')
m.drawcoastlines()
# plt.ylim([latrange[0],latrange[1]])
# plt.xlim([lonrange[0],lonrange[1]])
if gravity:
# read in gravity grid, plot contours on top
gravdat = np.loadtxt('/home/sippl/sandbox/gravity.txt')
# convert to regular grid
gravxi = np.arange(120., 128.01, 0.01)
gravyi = np.arange(-34., -30.01, 0.01)
gravzi = np.griddata(gravdat[:, 0],
gravdat[:, 1],
gravdat[:, 2],
gravxi,
gravyi,
interp='linear')
gravlon, gravlat = np.meshgrid(gravxi, gravyi)
gravx, gravy = m(gravlon, gravlat)
m.contour(gravx,
gravy,
gravzi, [-800, -400, -200, 0, 150, 300],
colors=['b', 'b', 'r', 'r', 'r', 'r'],
linestyles='-')
if mode == 'color':
m.pcolor(XImap, YImap, ZI, cmap='jet', vmin=32, vmax=52)
elif mode == 'contour':
m.contour(XImap, YImap, ZI)
elif mode == 'both':
m.pcolor(XImap, YImap, ZI, cmap='jet')
m.contour(XImap, YImap, ZI)
m.scatter(xvals_map, yvals_map, 120, zvals, cmap='jet', vmin=32, vmax=52)
lat_draw = np.arange(latrange[0], latrange[1], 1)
lon_draw = np.arange(lonrange[0], lonrange[1], 1)
m.drawmeridians(lon_draw, labels=[0, 0, 0, 1])
m.drawparallels(lat_draw, labels=[1, 0, 0, 0])
if z == 'H':
plt.colorbar(shrink=0.7, label='Moho depth [km]')
elif z == 'K':
plt.colorbar(shrink=0.7, label='vp/vs')
if save:
plt.savefig('Mohomap_Vers1.pdf', dpi=300)
def grid_query_unstruct(uvs, values, grid_res, method=None):
r"""Grid queries unstructured data given by coordinates and their values.
If you are looking to grid query structured data, such as an image, check
out :func:`grid_query_img`.
This function interpolates values on a rectangular grid given some sparse,
unstrucured samples. One use case is where you have some UV locations and
their associated colors, and you want to "paint the colors" on a UV canvas.
Args:
uvs (numpy.ndarray): N-by-2 array of UV coordinates where we have
values (e.g., colors). See
:func:`xiuminglib.blender.object.smart_uv_unwrap` for the UV
coordinate convention.
values (numpy.ndarray): N-by-M array of M-D values at the N UV
locations, or N-array of scalar values at the N UV locations.
Channels are interpolated independently.
grid_res (array_like): Resolution (height first; then width) of
the query grid.
method (dict, optional): Dictionary of method-specific parameters.
Implemented methods and their default parameters:
.. code-block:: python
# Default
method = {
'func': 'griddata',
# Which SciPy function to call.
'func_underlying': 'linear',
# Fed to `griddata` as the `method` parameter.
'fill_value': (0,), # black
# Will be used to fill in pixels outside the convex hulls
# formed by the UV locations, and if `max_l1_interp` is
# provided, also the pixels whose interpolation is too much
# of a stretch to be trusted. In the context of "canvas
# painting," this will be the canvas' base color.
'max_l1_interp': np.inf, # trust/accept all interpolations
# Maximum L1 distance, which we can trust in interpolation,
# to pixels that have values. Interpolation across a longer
# range will not be trusted, and hence will be filled with
# `fill_value`.
}
.. code-block:: python
method = {
'func': 'rbf',
# Which SciPy function to call.
'func_underlying': 'linear',
# Fed to `Rbf` as the `method` parameter.
'smooth': 0, # no smoothing
# Fed to `Rbf` as the `smooth` parameter.
}
Returns:
numpy.ndarray: Interpolated values at query locations, of shape
``grid_res`` for single-channel input or ``(grid_res[0], grid_res[1],
values.shape[2])`` for multi-channel input.
"""
if values.ndim == 1:
values = values.reshape(-1, 1)
assert values.ndim == 2 and values.shape[0] == uvs.shape[0]
if method is None:
method = {'func': 'griddata'}
h, w = grid_res
# Generate query coordinates
grid_x, grid_y = np.meshgrid(np.linspace(0, 1, w), np.linspace(0, 1, h))
# +---> x
# |
# v y
grid_u, grid_v = grid_x, 1 - grid_y
# ^ v
# |
# +---> u
if method['func'] == 'griddata':
from scipy.interpolate import griddata
func_underlying = method.get('func_underlying', 'linear')
fill_value = method.get('fill_value', (0, ))
max_l1_interp = method.get('max_l1_interp', np.inf)
fill_value = np.array(fill_value)
if len(fill_value) == 1:
fill_value = np.tile(fill_value, values.shape[1])
assert len(fill_value) == values.shape[1]
if max_l1_interp is None:
max_l1_interp = np.inf # trust everything
# Figure out which pixels can be trusted
has_value = np.zeros((h, w), dtype=np.uint8)
ri = ((1 - uvs[:, 1]) * (h - 1)).astype(int).ravel()
ci = (uvs[:, 0] * (w - 1)).astype(int).ravel()
in_canvas = np.logical_and.reduce(
(ri >= 0, ri < h, ci >= 0,
ci < w)) # to ignore out-of-canvas points
has_value[ri[in_canvas], ci[in_canvas]] = 1
dist2val = cv2.distanceTransform(1 - has_value, cv2.DIST_L1, 3)
trusted = dist2val <= max_l1_interp
# Process each color channel separately
interps = []
for ch_i in range(values.shape[1]):
v_fill = fill_value[ch_i]
v = values[:, ch_i]
interp = griddata(uvs,
v, (grid_u, grid_v),
method=func_underlying,
fill_value=v_fill)
interp[~trusted] = v_fill
interps.append(interp)
interps = np.dstack(interps)
elif method['func'] == 'rbf':
from scipy.interpolate import Rbf
func_underlying = method.get('func_underlying', 'linear')
smooth = method.get('smooth', 0)
# Process each color channel separately
interps = []
for ch_i in range(values.shape[1]):
v = values[:, ch_i]
rbfi = Rbf(uvs[:, 0],
uvs[:, 1],
v,
function=func_underlying,
smooth=smooth)
interp = rbfi(grid_u, grid_v)
interps.append(interp)
interps = np.dstack(interps)
else:
raise NotImplementedError(method['func'])
if interps.shape[2] == 1:
return interps[:, :, 0].squeeze()
return interps
df.loc[i, 'easting'] = list(utm.from_latlon(df.loc[i, 'lat'], df.loc[i, 'lon'], zone, 'U'))[0] # easting
df.loc[i, 'northing'] = list(utm.from_latlon(df.loc[i, 'lat'], df.loc[i, 'lon'], zone, 'U'))[1] # northing
df.loc[i, 'zone'] = list(utm.from_latlon(df.loc[i, 'lat'], df.loc[i, 'lon'], zone, 'U'))[2] # zone
df.loc[i, 'zone_letter'] = list(utm.from_latlon(df.loc[i, 'lat'], df.loc[i, 'lon'], zone, 'U'))[3] # zone letter
df = df[['prcs', 'lon', 'lat', 'easting', 'northing']]
df.rename(columns={'easting': 'x', # depending on the format of input data
'northing': 'y'}, inplace=True)
step = 2500
extent = x_min, x_max, y_min, y_max = [100161.17256633355, 598195.012411898, 5839614.174655632, 6654300.485022815]
grid_x, grid_y = np.mgrid[x_min:x_max:step, y_min:y_max:step]
rbfi = Rbf(df.x, df.y, df.prcs, function='linear', smooth=200000)
di = rbfi(grid_x, grid_y)
import utm
coords = zip(grid_x.flatten(), grid_y.flatten())
df_interp = pd.DataFrame(coords, columns=['easting', 'northing'])
# recalculate interpolated values with utm coordinates back in lat/lon
zone = 11
for c in df_interp.index:
df_interp.at[c, 'lat'] = list(utm.to_latlon(df_interp.at[c, 'easting'], df_interp.at[c, 'northing'], zone, 'U'))[0]
df_interp.at[c, 'lat'] = list(utm.to_latlon(df_interp.at[c, 'easting'], df_interp.at[c, 'northing'], zone, 'U'))[1]
mapped = zip(df_interp.lon, df_interp.lat, df_interp.easting, df_interp.northing, di.flatten())
mapped = set(mapped)
'function': 'thin_plate',
}
#############
# get params (x) and cost (z)
x, z = xyz.T[:,:-1], xyz.T[:,-1]
#HACK: remove any duplicate points by adding noise
_x = x + np.random.normal(scale=1e-8, size=x.shape)
if len(z) > N:
N = max(int(round(len(z)/float(N))),1)
print "for speed, sampling {} down to {}".format(len(z),len(z)/N)
x, _x, z = x[::N], _x[::N], z[::N]
f = Rbf(*np.vstack((_x.T, z)), **args)
f.__doc__ = model.__doc__
# convert to 'model' format (i.e. takes a parameter vector)
_model = lambda x: f(*x).tolist()
_model.__doc__ = f.__doc__
mz = np.argmin(z)
print "min: {}; min@f: {}".format(z[mz], f(*x[mz]))
mz = np.argmax(z)
print "max: {}; max@f: {}".format(z[mz], f(*x[mz]))
# print "TOOK: %s" % (time.time() - start)
# plot
#############
# specify 2-of-N dim (with bounds) and (N-2) with values
def create_contour(self,
fields=None,
time=None,
function='cubic',
subplot_index=(0, ),
grid_delta=(0.01, 0.01),
grid_buffer=0.1,
**kwargs):
"""
Extracts, grids, and creates a contour plot. If subplots have not been
added yet, an axis will be created assuming that there is only going
to be one plot.
Parameters
----------
fields : dict
Dictionary of fields to use for x, y, and z data.
time : datetime
Time in which to slice through objects.
function : string
Defaults to cubic function for interpolation.
See scipy.interpolate.Rbf for additional options.
subplot_index : 1 or 2D tuple, list, or array
The index of the subplot to set the x range of.
grid_delta : 1D tuple, list, or array
x and y deltas for creating grid.
grid_buffer : float
Buffer to apply to grid.
**kwargs : keyword arguments
The keyword arguments for :func:`plt.contour`
Returns
-------
ax : matplotlib axis handle
The matplotlib axis handle of the plot.
"""
# Get x, y, and z data by looping through each dictionary
# item and extracting data from appropriate time
x = []
y = []
z = []
for ds in self._arm:
obj = self._arm[ds]
field = fields[ds]
x.append(obj[field[0]].sel(time=time).values.tolist())
y.append(obj[field[1]].sel(time=time).values.tolist())
z.append(obj[field[2]].sel(time=time).values.tolist())
# Create a meshgrid for gridding onto
xs = np.arange(
np.min(x) - grid_buffer,
np.max(x) + grid_buffer, grid_delta[0])
ys = np.arange(
np.min(y) - grid_buffer,
np.max(y) + grid_buffer, grid_delta[1])
xi, yi = np.meshgrid(xs, ys)
# Use scipy radial basis function to interpolate data onto grid
rbf = Rbf(x, y, z, function=function)
zi = rbf(xi, yi)
# Create contour plot
self.contourf(xi, yi, zi, subplot_index=subplot_index, **kwargs)
return self.axes[subplot_index]
def save_single_plot(layout_fn, csv_fn, output_fn):
layout = imread(layout_fn)
a = pd.read_csv(csv_fn)
image_width = len(layout[0])
image_height = len(layout)
print("Image Width: %d; Image Height: %d" % (image_width, image_height))
grid_width = image_width
grid_height = image_height
num_x = image_width // 8
num_y = num_x // (image_width // image_height)
print("Resolution: %0.2f x %0.2f" % (num_x, num_y))
x = np.linspace(0, grid_width, num_x)
y = np.linspace(0, grid_height, num_y)
gx, gy = np.meshgrid(x, y)
gx, gy = gx.flatten(), gy.flatten()
# -80dBm: Unstable; -30dBm: Perfect signal
# Source: https://eyesaas.com/wi-fi-signal-strength/
levels = [-85, -80, -75, -70, -65, -60, -55, -50, -45, -40, -35, -30, -25]
interpolate = True
f = pp.figure()
# Use AxesGrid to create subplots
# Subplots not used, but useful for multiple floors
image_grid = AxesGrid(f,
111,
nrows_ncols=(1, 1),
axes_pad=0.1,
label_mode="1",
share_all=True,
cbar_location="right",
cbar_mode="single",
cbar_size="3%")
for beacon, i in zip(sources, range(len(sources))):
# Hide labels
image_grid[i].xaxis.set_visible(False)
image_grid[i].yaxis.set_visible(False)
if interpolate:
# Interpolate the data
rbf = Rbf(a['Drawing X'],
a['Drawing Y'],
a[beacon],
function='linear') #possibly logarithmic?
# Run rbf() on the data to find the interpolated value
z = rbf(gx, gy)
z = z.reshape((num_y, num_x))
# Render the interpolated data (red, yellow, blue)
image = image_grid[i].imshow(z,
vmin=-85,
vmax=-25,
extent=(0, image_width, image_height,
0),
cmap='RdYlBu_r',
alpha=1)
else:
# If value not interpolated
z = ml.griddata(a['Drawing X'], a['Drawing Y'], a[beacon], x, y)
c = image_grid[i].contourf(x, y, z, levels, alpha=0.5)
image_grid[i].imshow(layout, interpolation='bicubic', zorder=100)
# colorbar setup
image_grid.cbar_axes[0].colorbar(image)
image_grid.cbar_axes[0].set_yticks(levels)
# Add titles
for ax, im_title in zip(image_grid, sources):
t = add_inner_title(ax, "Layout Name: %s" % layout_fn, loc=3)
t.patch.set_alpha(0.5)
# pp.show()
pp.savefig(output_fn, bbox_inches='tight', transparent=True)
def draw_function():
if btn7.get() == '默认':
mark2 = 0
mmin = None
else:
mark2 = 1
mmin = float(btn7.get())
if btn8.get() == '默认':
mark3 = 0
mmax = None
else:
mark3 = 1
mmax = float(btn8.get())
#------------警告提示框---------
if mark1 == 0 and mark2 == 0 and mark3 == 0:
pass
elif mark1 == 0 and (mark2 == 1 or mark3 == 1):
tk.messagebox.showwarning('警告', '色阶默认情况下，图例最小值和图例最大值均应为“默认”')
return
else:
tk.messagebox.showwarning('警告', '色阶非默认情况下，需同时自定义色阶级数、图例最小值和图例最大值')
return
path0 = 'DTool/dishi.shp'
# path1 = 'C:/Users/zhanLf/Desktop/Python/DTool/shengjie.shp'
# a = gpd.GeoDataFrame.from_file(r'C:\Users\zhanlf\Desktop\Python\DTool\dishi.shp')
file = shapefile.Reader(path0)
rec = file.shapeRecords()
polygon = list()
for r in rec:
polygon.append(Polygon(r.shape.points))
poly = cascaded_union(polygon) #并集
ext = list(poly.exterior.coords) #外部点
codes = [Path.MOVETO] + [Path.LINETO] * (len(ext) - 1) + [Path.CLOSEPOLY]
# codes += [Path.CLOSEPOLY]
ext.append(ext[0]) #起始点
path = Path(np.array(ext), codes)
patch = PathPatch(path, facecolor='None')
df = pd.read_csv(file_path, sep=',', encoding='GB2312')
x, y = df['经度'], df['纬度']
xi = np.arange(113, 118.5, 0.01)
yi = np.arange(24, 31, 0.01)
olon, olat = np.meshgrid(xi, yi)
# 空间插值计算
func = Rbf(x, y, z, function='linear')
rain_data_new = func(olon, olat)
ax = plt.axes(projection=ccrs.PlateCarree())
box = [113.4, 118.7, 24.1, 30.4]
ax.set_extent(box, crs=ccrs.PlateCarree())
ax.add_patch(patch)
shp = list(shpreader.Reader(path0).geometries())
ax.add_geometries(shp,
ccrs.PlateCarree(),
edgecolor='black',
facecolor='none',
alpha=1,
linewidth=0.5) #加底图
''' 不可取方法，太耗时间
#for i in range(0,olat.shape[1]):
# print(i)
# for j in range(0,olat.shape[0]):
# if geometry.Point(np.array([olon[0,i],olat[j,0]])).within(geometry.shape(shps)):
# continue
# else:
# rain_data_new[j,i] = np.nan
'''
if mark1 == 1 and mark2 == 1 and mark3 == 1 and btn10.get() != 'CMA_Rain':
v = np.linspace(mmin, mmax, num=mnum, endpoint=True) #设置显示数值范围和级数
if color_mark == 1:
pic = plt.contourf(olon, olat, rain_data_new, v, cmap=plt.cm.jet)
elif color_mark == 2:
pic = plt.contourf(olon,
olat,
rain_data_new,
v,
cmap=plt.cm.rainbow)
elif color_mark == 3:
pic = plt.contourf(olon,
olat,
rain_data_new,
v,
cmap=plt.cm.gist_rainbow)
elif color_mark == 4:
pic = plt.contourf(olon, olat, rain_data_new, v, cmap=plt.cm.OrRd)
cbar = plt.colorbar(pic)
cbar.set_label(btn9.get(), fontproperties='SimHei') #图例label在右边
# elif mark1 == 1 and mark2 == 0 and mark3 == 0 and btn10.get() != 'CMA_Rain':
# # if color_mark == 1:
# # pic = plt.contourf(olon, olat, rain_data_new, mnum, cmap = plt.cm.jet)
# # elif color_mark == 2:
# # pic = plt.contourf(olon, olat, rain_data_new, mnum, cmap = plt.cm.rainbow)
# # elif color_mark == 3:
# # pic = plt.contourf(olon, olat, rain_data_new, mnum, cmap = plt.cm.gist_rainbow)
# # elif color_mark == 4:
# # pic = plt.contourf(olon, olat, rain_data_new, mnum, cmap = plt.cm.OrRd)
# # v = np.linspace(mmin, mmax, num = mnum, endpoint = True)
# pic = plt.contourf(olon, olat, rain_data_new, mnum, cmap = plt.cm.jet)
# cbar = plt.colorbar(pic)
# cbar.set_label(btn9.get(),fontproperties='SimHei')
elif btn10.get() == 'CMA_Rain':
rain_levels = [0, 0.1, 10, 25, 50, 100, 250, 2500]
rain_colors = [
'#FFFFFF', '#A6F28F', '#38A800', '#61B8FF', '#0000FF', '#FA00FA',
'#730000', '#400000'
]
pic = plt.contourf(olon,
olat,
rain_data_new,
levels=rain_levels,
colors=rain_colors)
cbar = plt.colorbar(pic, ticks=[0, 0.1, 10, 25, 50, 100, 250])
cbar.set_label(btn9.get(), fontproperties='SimHei') #图例label在右边
# cbar.make_axes(locations='top')
# cbar.ax.set_xlabel(btn9.get(),fontproperties='SimHei')
else:
if color_mark == 1:
pic = plt.contourf(olon, olat, rain_data_new, cmap=plt.cm.jet)
elif color_mark == 2:
pic = plt.contourf(olon, olat, rain_data_new, cmap=plt.cm.rainbow)
elif color_mark == 3:
pic = plt.contourf(olon,
olat,
rain_data_new,
cmap=plt.cm.gist_rainbow)
elif color_mark == 4:
pic = plt.contourf(olon, olat, rain_data_new, cmap=plt.cm.OrRd)
cbar = plt.colorbar(pic)
cbar.set_label(btn9.get(), fontproperties='SimHei') #图例label在右边
for collection in pic.collections:
collection.set_clip_path(patch) #设置显示区域
plt.scatter(x, y, marker='.', c='k', s=10)
# cbar.ax.set_xlabel(btn9.get(),fontproperties='SimHei') #图例label在下边
fig = plt.gcf()
fig.set_size_inches(5, 4)
plt.savefig('pics.tif', bbox_inches='tight')
plt.close()
wifi_img = Image.open('pics.tif')
img = ImageTk.PhotoImage(wifi_img)
window.img = img # to prevent the image garbage collected.
canvas.create_image(200, 180, anchor='center', image=img)
Use scipy to interpolate the value of a scalar known on a set of points on a new set of points where the scalar is not defined. Two interpolation methods are possible: Radial Basis Function, Nearest Point. ''' from scipy.interpolate import Rbf, NearestNDInterpolator as Near import numpy as np # np.random.seed(0) # a small set of points for which the scalar is given x, y, z = np.random.rand(3, 20) scals = z # scalar value is just z component # build the interpolator itr = Rbf(x, y, z, scals) # Radial Basis Function interpolator # itr = Near(list(zip(x,y,z)), scals) # Nearest-neighbour interpolator # generate a new set of points t = np.linspace(0, 7, 100) xi, yi, zi = [np.sin(t)/10+.5, np.cos(t)/5+.5, (t-1)/5] # an helix # interpolate scalar values on the new set scalsi = itr(xi, yi, zi) from vtkplotter import Plotter, Points, Text vp = Plotter(verbose=0, bg='w') vp.add(Points([x, y, z], r=10, alpha=0.5)).pointColors(scals) vp.add(Points([xi, yi, zi])).pointColors(scalsi)
def changeToRebinedMjuAveraging(self,
rebinType='spline',
dE1=1,
dE2=0.1,
dK=0.01,
s=0):
# rebinType possible values:
# 'spline'
# 'rbf-smooth'
self.energyOriginal = copy(self.energy)
self.mjuOriginal = copy(self.mju)
# sort array in there are decreasing points
sortIndexes = self.energy.argsort()
sortedEnergy = self.energy[sortIndexes]
sortedMju = self.mju[sortIndexes]
dE = dE1
newE = []
newMju = []
#take data before E1
E1Region = where(sortedEnergy < self.E1)
E1Energy = sortedEnergy[E1Region]
E1Mju = sortedMju[E1Region]
newE.append(E1Energy[0])
newMju.append(E1Mju[0])
eCenter = E1Energy[0] + dE / 2
while eCenter + dE / 2 < self.E1:
reg = where(
logical_and(sortedEnergy > eCenter - dE / 2,
sortedEnergy < eCenter + dE / 2))
valE = sortedEnergy[reg].sum() / len(sortedEnergy[reg])
val = sortedMju[reg].sum() / len(sortedMju[reg])
newE.append(valE)
newMju.append(val)
eCenter = eCenter + dE
dE = dE2
#take data before E0+50
E0Region = where(
logical_and(sortedEnergy > self.E1, sortedEnergy < self.E0 + 50))
E0Energy = sortedEnergy[E0Region]
E0Mju = sortedMju[E0Region]
newE.append(E0Energy[0])
newMju.append(E0Mju[0])
eCenter = E0Energy[0] + dE / 2
while eCenter + dE / 2 < self.E0 + 50:
reg = where(
logical_and(sortedEnergy > eCenter - dE / 2,
sortedEnergy < eCenter + dE / 2))
# print("reg", len(reg), reg)
# if reg==[]:
# eCenter = eCenter + dE
if len(reg[0]) == 1:
valE = sortedEnergy[reg][0]
val = sortedMju[reg][0]
newE.append(valE)
newMju.append(val)
if len(reg[0]) > 1:
valE = sortedEnergy[reg].sum() / len(sortedEnergy[reg])
val = sortedMju[reg].sum() / len(sortedMju[reg])
newE.append(valE)
newMju.append(val)
eCenter = eCenter + dE
dk = dK
#take data after E0
E3Region = where(
logical_and(sortedEnergy > self.E0 + 50, sortedEnergy < self.E3))
E3Energy = sortedEnergy[E3Region]
E3Mju = sortedMju[E3Region]
newE.append(E3Energy[0])
newMju.append(E3Mju[0])
# kExafsMin = sqrt( (2*me/hbar**2) * (self.E0+50-self.E0) * 1.602*10**-19 ) *10**-10
# kExafsMax = sqrt( (2*me/hbar**2) * (self.E3-self.E0) * 1.602*10**-19 ) *10**-10
kScale = sqrt((2 * me / hbar**2) *
(E3Energy - self.E0) * 1.602 * 10**-19) * 10**-10
# eScale = kScale**2 * 10**20 / (1.602*10**-19 * (2*me/hbar**2)) + self.E0
kCenter = kScale[0] + dk / 2
while kCenter + dk / 2 < kScale[-1]:
reg = where(
logical_and(kScale > kCenter - dE / 2,
kScale < kCenter + dE / 2))
# print("reg", len(reg), reg)
# if reg==[]:
# eCenter = eCenter + dE
if len(reg[0]) == 1:
valE = E3Energy[reg][0]
val = E3Mju[reg][0]
newE.append(valE)
newMju.append(val)
if len(reg[0]) > 1:
valE = E3Energy[reg].sum() / len(E3Energy[reg])
val = E3Mju[reg].sum() / len(E3Mju[reg])
newE.append(valE)
newMju.append(val)
kCenter = kCenter + dk
newE = asarray(newE)
newMju = asarray(newMju)
kExafsMin = sqrt((2 * me / hbar**2) *
(self.E0 + 50 - self.E0) * 1.602 * 10**-19) * 10**-10
kExafsMax = sqrt((2 * me / hbar**2) *
(self.E3 - self.E0) * 1.602 * 10**-19) * 10**-10
kScale = arange(kExafsMin, kExafsMax, dk, dtype='float64')
eScale = kScale**2 * 10**20 / (1.602 * 10**-19 *
(2 * me / hbar**2)) + self.E0
a1 = arange(self.energy[0], self.E1, self.dE1, dtype='float64')
a2 = arange(self.E1, self.E0 + 50, self.dE2, dtype='float64')
self.energyRebined = concatenate((a1, a2, eScale.astype('float64')))
if rebinType == 'spline':
uniqueEnergy, uniqueIndexes = unique(newE, return_index=True)
newE = newE[uniqueIndexes]
newMju = newMju[uniqueIndexes]
newE = newE[~isnan(newE)]
newMju = newMju[~isnan(newMju)]
spl = InterpolatedUnivariateSpline(newE, newMju, k=1)
if rebinType == 'rbf-smooth':
spl = Rbf(
newE,
newMju,
function='multiquadric',
epsilon=3, #epsilon 3 woks fine
smooth=s)
self.mjuRebined = spl(self.energyRebined)
self.mjuRebined = self.mjuRebined[1:-2]
self.energyRebined = self.energyRebined[1:-2]
self.energy = copy(self.energyRebined)
self.mju = copy(self.mjuRebined)
self.mjuDerivative = gradient(self.mju)
self.redoExtraction()
def makeplot(x, y, z, this_slice, this_bestval, xlabel, ylabel, zlabel, title,
pngoutfile):
fig = plt.figure(figsize=(7.5, 6))
ax = plt.gca()
sliceindexes = np.where(this_slice == this_bestval)
slicex = x[sliceindexes]
slicey = y[sliceindexes]
slicez = z[sliceindexes]
slicex = np.array(slicex)
slicey = np.array(slicey)
slicez = np.array(slicez)
if len(slicez) > 3:
# Set up a regular grid of interpolation points
xi, yi = np.linspace(slicex.min(), slicex.max(),
60), np.linspace(slicey.min(), slicey.max(), 60)
xi, yi = np.meshgrid(xi, yi)
# Interpolate using Rbf
rbf = Rbf(slicex, slicey, slicez, function='cubic')
zi = rbf(xi, yi)
q = [0.999]
vmax = np.quantile(slicez, q)
zi[zi > vmax] = vmax
# replace nan with vmax (using workaround)
val = -99999.9
zi[zi == 0.0] = val
zi = np.nan_to_num(zi)
zi[zi == 0] = vmax
zi[zi == val] = 0.0
# plot
pl2 = plt.imshow(
zi,
vmin=slicez.min(),
vmax=slicez.max(),
origin='lower',
extent=[slicex.min(),
slicex.max(),
slicey.min(),
slicey.max()],
aspect='auto',
cmap=cmap)
ax.set_xlabel(xlabel, fontsize=18)
ax.set_ylabel(ylabel, fontsize=18)
clb = fig.colorbar(pl2)
clb.set_label(label=zlabel, size=16)
clb.ax.tick_params(labelsize=18)
#####################################
fig.subplots_adjust(left=0.13,
bottom=0.12,
right=0.93,
top=0.94,
wspace=0,
hspace=0)
fig = gcf()
fig.suptitle(title, fontsize=18, y=0.99)
ax.tick_params(axis='both', which='major', labelsize=16)
ax.tick_params(axis='both', which='minor', labelsize=16)
fig.savefig(pngoutfile, bbox_inches='tight')
plt.close()
def draw_function():
if markclick == 0: # mclick 如果不存在，则鼠标未点击色阶级数，则给mark1和mnum赋初始值
mark1 = 0
mnum = None
else:
mark1 = mark1_1
mnum = mnum_1
if btn_legendmin.get() == '默认':
mark2 = 0
mmin = None
else:
mark2 = 1
mmin = float(btn_legendmin.get())
if btn_legendmax.get() == '默认':
mark3 = 0
mmax = None
else:
mark3 = 1
mmax = float(btn_legendmax.get())
if mmax <= mmin:
tm.showwarning('警告', '图例最大值应大于最小值！')
# ------------警告提示框---------
if (mark1 == 0 or mark1 == 1) and mark2 == 0 and mark3 == 0:
pass
elif color_mark == 6:
pass
elif mark1 == 0 and (mark2 == 1 or mark3 == 1):
tm.showwarning('警告', '色阶级数默认情况下，图例最小值和图例最大值均应为“默认”。')
return
elif mark1 == 1 and mark2 == 1 and mark3 == 1:
pass
else:
tm.showinfo('提示', '色阶级数非默认情况下，需同时自定义设置图例最小值和图例最大值；否则图例最大值和最小值以默认值绘出。')
pass
path0 = 'DTool/dishi.shp'
file = shapefile.Reader(path0)
rec = file.shapeRecords()
polygon = list()
for r in rec:
polygon.append(Polygon(r.shape.points))
poly = cascaded_union(polygon) # 并集
ext = list(poly.exterior.coords) # 外部点
codes = [Path.MOVETO] + [Path.LINETO] * (len(ext) - 1) + [Path.CLOSEPOLY]
# codes += [Path.CLOSEPOLY]
ext.append(ext[0]) # 起始点
path = Path(np.array(ext), codes)
patch = PathPatch(path, facecolor='None')
x, y = df['经度'], df['纬度']
xi = np.arange(113, 118.5, 0.01)
yi = np.arange(24, 31, 0.01)
olon, olat = np.meshgrid(xi, yi)
# Rbf空间插值
func = Rbf(x, y, z, function='linear')
oz = func(olon, olat)
# 克里金插值
#ok = OrdinaryKriging(x, y, z, variogram_model='linear')
#oz, ss = ok.execute('grid', xi, yi)
ax = plt.axes(projection=ccrs.PlateCarree())
box = [113.4, 118.7, 24.1, 30.4]
ax.set_extent(box, crs=ccrs.PlateCarree())
ax.add_patch(patch)
shp = list(shpreader.Reader(path0).geometries())
ax.add_geometries(shp,
ccrs.PlateCarree(),
edgecolor='black',
facecolor='none',
alpha=0.3,
linewidth=0.5) # 加底图
if mark1 == 1 and mark2 == 1 and mark3 == 1 and btn_style.get(
) != 'CMA_Rain':
v = np.linspace(mmin, mmax, num=mnum, endpoint=True) # 设置显示数值范围和级数
if color_mark == 1:
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.jet)
elif color_mark == 2:
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.rainbow)
elif color_mark == 3:
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.gist_rainbow)
elif color_mark == 4:
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.OrRd)
elif btn_style.get() == 'CMA_Rain':
# 应加入超出levels的提示
try:
rain_levels = [0, 0.1, 10, 25, 50, 100, 250, 2500]
rain_colors = [
'#FFFFFF', '#A6F28F', '#38A800', '#61B8FF', '#0000FF',
'#FA00FA', '#730000', '#400000'
]
pic = plt.contourf(olon,
olat,
oz,
levels=rain_levels,
colors=rain_colors)
# cbar = plt.colorbar(pic, ticks=[0, 0.1, 10, 25, 50, 100, 250])
# position = fig.add_axes([0.65, 0.15, 0.03, 0.3]) # 位置
# plt.colorbar(pic, ticks=[0, 0.1, 10, 25, 50, 100, 250], cax=position, orientation='vertical')
# cbar.set_label(btn9.get(), fontproperties='SimHei') # 图例label在右边
except:
if np.min(z) < 0:
tm.showinfo(message='存在负数，超出降水图例范围！请换其他颜色样式。')
elif np.max(z) > 2500:
tm.showinfo(message='降水量过大，请何查数据！或请换其他颜色样式。')
# cbar.make_axes(locations='top')
# cbar.ax.set_xlabel(btn9.get(),fontproperties='SimHei')
else:
if color_mark == 1:
if mark1 == 0: # 未设置级数
pic = plt.contourf(olon, olat, oz, cmap=plt.cm.jet)
else:
v = np.linspace(np.min(oz),
np.max(oz),
num=mnum,
endpoint=True) # 设置显示数值范围和级数
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.jet)
elif color_mark == 2:
if mark1 == 0:
pic = plt.contourf(olon, olat, oz, cmap=plt.cm.rainbow)
else:
v = np.linspace(np.min(oz),
np.max(oz),
num=mnum,
endpoint=True)
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.rainbow)
elif color_mark == 3:
if mark1 == 0:
pic = plt.contourf(olon, olat, oz, cmap=plt.cm.gist_rainbow)
else:
v = np.linspace(np.min(oz),
np.max(oz),
num=mnum,
endpoint=True)
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.gist_rainbow)
elif color_mark == 4:
if mark1 == 0:
pic = plt.contourf(olon, olat, oz, cmap=plt.cm.OrRd)
else:
v = np.linspace(np.min(oz),
np.max(oz),
num=mnum,
endpoint=True)
pic = plt.contourf(olon, olat, oz, v, cmap=plt.cm.OrRd)
elif color_mark == 6: # 自定义颜色
# 判断出自定义颜色级数
jishu_colors = []
for index, r in enumerate(rgb):
if r == None:
num_color = index
break
else:
jishu_colors.append(r)
if mark2 == 1 and mark3 == 1: # mark2最小值；mark3最大值
v = np.linspace(mmin, mmax, num=num_color + 1,
endpoint=True) # 设置显示数值范围和级数
pic = plt.contourf(olon, olat, oz, v, colors=jishu_colors)
else:
v = np.linspace(np.min(oz),
np.max(oz),
num=len(jishu_colors) + 1,
endpoint=True)
pic = plt.contourf(olon, olat, oz, v, colors=jishu_colors)
for collection in pic.collections:
collection.set_clip_path(patch) # 设置显示区域
plt.scatter(x, y, marker='.', c='k', s=10) # 绘制站点
# 添加显示站名、数值等标签
for i in range(len(z)):
plt.text(x[i], y[i] + 0.05, df['站名'][i], size=5.5, weight=2, wrap=True)
# 添加单位标注
plt.text(117.75, 27.1, btn_legendunit.get(), size=8, weight=2)
fig = plt.gcf()
fig.set_size_inches(6, 4) # 设置图片大小
plt.axis('off') # 去除四边框框
if btn_style.get() == 'CMA_Rain':
position = fig.add_axes([0.65, 0.15, 0.03, 0.3]) # 位置
plt.colorbar(pic,
ticks=[0, 0.1, 10, 25, 50, 100, 250],
cax=position,
orientation='vertical')
else:
position = fig.add_axes([0.65, 0.15, 0.03, 0.3]) # 位置
plt.colorbar(pic, cax=position, orientation='vertical')
plt.savefig('pics_dpi100.png', dpi=100, bbox_inches='tight')
plt.savefig('pics_dpi300.png', dpi=300, bbox_inches='tight')
plt.close()
wifi_img = Image.open('pics_dpi100.png')
img = ImageTk.PhotoImage(wifi_img)
window.img = img # to prevent the image garbage collected.
canvas.create_image(200, 180, anchor='center', image=img) # 设置生成的图片位置
print "Calculated values for {0} files.".format(len(alts))
alts = np.array(alts)
azs = np.array(azs)
powers = np.array(powers)
import matplotlib.pyplot as plt
print "Plotting..."
x = azs
y = alts
z = powers
xi, yi = np.linspace(0, 360, 360), np.linspace(0, 90, 90)
xi, yi = np.meshgrid(xi, yi)
rbf = Rbf(x, y, z, function='linear')
#zi = griddata((x,y), z, (xi,yi), method='cubic')
zi = rbf(xi, yi)
plt.imshow(zi,
vmin=z.min(),
vmax=z.max(),
origin='lower',
extent=[0, 360, 0, 90],
aspect='auto')
plt.colorbar()
plt.scatter(x, y, c=z)
plt.title("Total Power from {0} to {1} MHz".format(fmin, fmax))
plt.xlabel("Azimuth of Observation (degrees)")
c_easting = [v['easting'] for v in clusters.values()]
c_northing = [v['northing'] for v in clusters.values()]
c_elevation = [v['elevation'] for v in clusters.values()]
stiffness = [v["stiffness"] for v in clusters.values()]
stress = [v["stress"] for v in clusters.values()]
strain = [v["strain"] for v in clusters.values()]
point_convex_hull = ConvexHull(xyz)
points = np.vstack([c_easting, c_northing, c_elevation]).T
cluster_convex_hull = ConvexHull(points)
stress_int = Rbf(c_easting,
c_northing,
c_elevation,
np.log10(stress),
function='inverse',
smooth=0.4)
strain_int = Rbf(c_easting,
c_northing,
c_elevation,
np.log10(strain),
function='inverse',
smooth=0.4)
stiffness_int = Rbf(c_easting,
c_northing,
c_elevation,
np.log10(stiffness),
function='inverse',
smooth=0.4)
def eeg_topoplot(topography,
sensorlocations,
plotsensors=False,
resolution=151,
contour=False,
masked=True,
plothead=True,
method='Rbf',
plothead_kwargs=None,
**kwargs):
"""Plot distribution to a head surface, derived from some sensor locations.
The sensor locations (polar coordinates; theta, radius) are plotted on top of a scalp
Largely based on the plotHeadTopography and plotHeadOutline functions as part of the PyMVPA package (http://www.pymvpa.org)
source: https://github.com/PyMVPA/PyMVPA/blob/master/mvpa2/misc/plot/topo.py
Args:
topography : array; a vector containing the values corresponding to each of the sensors.
sensorlocations : (nsensors x 2) array; first value is theta (in degree) and the second is the radius
The order of the sensors has to match those of the `topography` vector.
plotsensors: bool; If True, the sensor will be plotted on their projected coordinates. No sensor are shown otherwise.
plothead: bool; If True, a head outline is plotted.
plothead_kwargs: dict; Additional keyword arguments passed to `plotHeadOutline()`.
resolution: int; Number of surface samples along both x and y-axis.
contour: bool; If True, contour lines are shown on top of the map
masked: bool; If True, all surface sample extending to head outline will be masked.
method: 'Rbf' (default) or 'Grid'; Rbf allows for extrapolation outside the data points (scipy.interpolate.Rbf); Grid does not allow this
**kwargs: All additional arguments will be passed to the `pylab.imshow()` instance showing the topography.
Returns:
(maps,maps_contourlines,head,sensors)
The corresponding matplotlib objects are returned if plotted, ie. if plothead is set to `False`, `head` will be `None`.
maps : The colormap that makes the actual plot, a matplotlib.image.AxesImage instance.
maps_contourlines : the contourlines, a matplotlib.contour.QuadContourSet instance
head : the outline of the head as returned by `eeg_plotHeadOutline()`, a matplotlib.lines.Line2d instance
sensors : The dots marking the electrodes, a matplotlib.lines.Line2d instance. """
from scipy.interpolate import Rbf
if plothead_kwargs is None:
plothead_kwargs = {}
th = sensorlocations[:, 0]
rd = sensorlocations[:, 1]
# theta values assumed to be in degrees; if already in radians, comment out next line
th = pi * th / 180.0
y = rd * np.cos(th)
x = rd * np.sin(th)
r = np.max(rd)
# size of each square
ssh = float(r) / resolution # half-size
ss = ssh * 2.0 # full-size
cx, cy = 0, 0
# Generate a grid and interpolate using either the griddata module (w/o extrapolation) or scipy.interpolate.Rbf (with extrapolation outside data-points)
xi = np.arange(cx - r, cx + r, ss) + ssh
yi = np.arange(cy - r, cy + r, ss) + ssh
xi, yi = meshgrid(xi, yi)
if method == 'grid':
topo = griddata(x, y, topography, xi, yi)
else:
rbf = Rbf(x, y, topography, epsilon=0.05)
topo = rbf(xi, yi)
# mask values outside the head
if masked:
notinhead = np.greater_equal((xi - cx)**2 + (yi - cy)**2, (1.0 * r)**2)
topo = np.ma.masked_where(notinhead, topo)
# show topography + contourlines or only the topography
if contour:
maps = plt.imshow(topo,
origin="lower",
extent=(-r, r, -r, r),
cmap=plt.cm.jet,
**kwargs)
levels = 5
maps_contourlines = plt.contour(xi,
yi,
topo,
levels,
linewidths=2,
colors='grey',
**kwargs)
# We don't need dashed contour lines to indicate negative
# regions, so let's turn them off.
for c in maps_contourlines.collections:
c.set_linestyle('solid')
#for filled & discrete contours instead of the 256-color map, use this:
#maps_contourlines = plt.contourf(xi,yi,topo,levels,origin="lower",cmap=plt.cm.jet, extent=(-r, r, -r, r), **kwargs)
else:
maps = plt.imshow(topo,
origin="lower",
extent=(-r, r, -r, r),
**kwargs)
maps_contourlines = None
if plothead:
#make head slightly smaller than r so that e.g. fp1 and fp2 are on the outline of the head
head = eeg_plot_head_outline(scale=0.75 * r,
shift=(cx / 2.0, cy / 2.0),
**plothead_kwargs)
else:
head = None
if plotsensors:
# plot projected sensor locations
sensors = plt.plot(x,
y,
c='black',
marker='o',
lw=0,
ms=6,
mew=1,
mec='black')
else:
sensors = None
plt.axis('off')
plt.axis('equal')
return maps, maps_contourlines, head, sensors
Two interpolation methods are possible:
Radial Basis Function (used here), and Nearest Point."""
import numpy as np
from vedo import *
from scipy.interpolate import Rbf, NearestNDInterpolator as Near
mesh = Mesh(dataurl + "bunny.obj").normalize()
pts = mesh.points()
# pick a subset of 100 points where a scalar descriptor is known
ptsubset = pts[:100]
# assume the descriptor value is some function of the point coord y
x, y, z = np.split(ptsubset, 3, axis=1)
desc = 3 * sin(4 * y)
# build the interpolator to determine the scalar value
# for the rest of mesh vertices:
itr = Rbf(x, y, z, desc) # Radial Basis Function interpolator
#itr = Near(ptsubset, desc) # Nearest-neighbour interpolator
# interpolate desciptor on the full set of mesh vertices
xi, yi, zi = np.split(pts, 3, axis=1)
interpolated_desc = itr(xi, yi, zi)
mesh.cmap('rainbow', interpolated_desc).addScalarBar(title='3sin(4y)')
rpts = Points(ptsubset, r=8, c='white')
show(mesh, rpts, __doc__, axes=1).close()
def interp_RZ(self, var):
x = np.average(self.xs, axis=1)
y = np.average(self.ys, axis=1)
d = self.vars[var]
return Rbf(x, y, d)
def interp_rbf(data,
sphere_origin,
sphere_target,
function='multiquadric',
epsilon=None,
smooth=0.1,
norm="angle"):
"""Interpolate data on the sphere, using radial basis functions.
Parameters
----------
data : (N,) ndarray
Function values on the unit sphere.
sphere_origin : Sphere
Positions of data values.
sphere_target : Sphere
M target positions for which to interpolate.
function : {'multiquadric', 'inverse', 'gaussian'}
Radial basis function.
epsilon : float
Radial basis function spread parameter. Defaults to approximate average
distance between nodes.
a good start
smooth : float
values greater than zero increase the smoothness of the
approximation with 0 as pure interpolation. Default: 0.1
norm : str
A string indicating the function that returns the
"distance" between two points.
'angle' - The angle between two vectors
'euclidean_norm' - The Euclidean distance
Returns
-------
v : (M,) ndarray
Interpolated values.
See Also
--------
scipy.interpolate.Rbf
"""
from scipy.interpolate import Rbf
def angle(x1, x2):
xx = np.arccos(np.clip((x1 * x2).sum(axis=0), -1, 1))
return np.nan_to_num(xx)
def euclidean_norm(x1, x2):
return np.sqrt(((x1 - x2)**2).sum(axis=0))
if norm == "angle":
norm = angle
elif norm == "euclidean_norm":
w_s = "The Euclidean norm used for interpolation is inaccurate "
w_s += "and will be deprecated in future versions. Please consider "
w_s += "using the 'angle' norm instead"
warnings.warn(w_s, DeprecationWarning)
norm = euclidean_norm
# Workaround for bug in older versions of SciPy that don't allow
# specification of epsilon None:
if epsilon is not None:
kwargs = {
'function': function,
'epsilon': epsilon,
'smooth': smooth,
'norm': norm
}
else:
kwargs = {'function': function, 'smooth': smooth, 'norm': norm}
rbfi = Rbf(sphere_origin.x, sphere_origin.y, sphere_origin.z, data,
**kwargs)
return rbfi(sphere_target.x, sphere_target.y, sphere_target.z)
# normalize
mean = x.mean()
std = x.std()
x = (x - mean) / std
timeseries.append(x)
# compute PDF
g, y = statsmodels_univariate_kde(x,
kernel=KERNEL,
clip=CLIP,
bw=BW,
gridsize=GRIDSIZE,
cut=CUT,
cumulative=CUMULATIVE)
# interp to the same grid
f = Rbf(g, y, function="multiquadric")
ikde = f(GRID)
PDFs.append(ikde)
PDFs = np.array(PDFs)
# --- Cluster offshore data ---
M = GaussianMixture(3,
n_init=200,
init_params="random",
random_state=42,
verbose=0,
covariance_type="full")
M.fit(of[["Hm0", "Tm01"]])
labels = M.predict(of[["Hm0", "Tm01"]])
C = []
'function': 'thin_plate',
}
#############
# get params (x) and cost (z)
x, z = xyz.T[:,:-1], xyz.T[:,-1]
#HACK: remove any duplicate points by adding noise
_x = x + np.random.normal(scale=1e-8, size=x.shape)
if len(z) > N:
N = max(int(round(len(z)/float(N))),1)
print("for speed, sampling {} down to {}".format(len(z),len(z)/N))
x, _x, z = x[::N], _x[::N], z[::N]
f = Rbf(*np.vstack((_x.T, z)), **args)
f.__doc__ = model.__doc__
# convert to 'model' format (i.e. takes a parameter vector)
_model = lambda x: f(*x).tolist()
_model.__doc__ = f.__doc__
mz = np.argmin(z)
print("min: {}; min@f: {}".format(z[mz], f(*x[mz])))
mz = np.argmax(z)
print("max: {}; max@f: {}".format(z[mz], f(*x[mz])))
# print("TOOK: %s" % (time.time() - start))
# plot
#############
# specify 2-of-N dim (with bounds) and (N-2) with values
def plot_vectors_from_spd_dir(self,
fields,
time=None,
subplot_index=(0, ),
mesh=False,
function='cubic',
grid_delta=(0.01, 0.01),
grid_buffer=0.1,
**kwargs):
"""
Extracts, grids, and creates a contour plot.
If subplots have not been added yet, an axis will be created
assuming that there is only going to be one plot.
Parameters
----------
fields : dict
Dictionary of fields to use for x, y, and z data.
time : datetime
Time in which to slice through objects.
mesh : boolean
Set to True to interpolate u and v to grid and create wind barbs.
function : string
Defaults to cubic function for interpolation.
See scipy.interpolate.Rbf for additional options.
grid_delta : 1D tuple, list, or array
x and y deltas for creating grid.
grid_buffer : float
Buffer to apply to grid.
**kwargs : keyword arguments
The keyword arguments for :func:`plt.barbs`
Returns
-------
ax : matplotlib axis handle
The matplotlib axis handle of the plot.
"""
# Get x, y, and z data by looping through each dictionary
# item and extracting data from appropriate time
x = []
y = []
wspd = []
wdir = []
for ds in self._arm:
obj = self._arm[ds]
field = fields[ds]
x.append(obj[field[0]].sel(time=time).values.tolist())
y.append(obj[field[1]].sel(time=time).values.tolist())
wspd.append(obj[field[2]].sel(time=time).values.tolist())
wdir.append(obj[field[3]].sel(time=time).values.tolist())
# Calculate u and v
tempu = -np.sin(np.deg2rad(wdir)) * wspd
tempv = -np.cos(np.deg2rad(wdir)) * wspd
if mesh is True:
# Create a meshgrid for gridding onto
xs = np.arange(
min(x) - grid_buffer,
max(x) + grid_buffer, grid_delta[0])
ys = np.arange(
min(y) - grid_buffer,
max(y) + grid_buffer, grid_delta[1])
xi, yi = np.meshgrid(xs, ys)
# Use scipy radial basis function to interpolate data onto grid
rbf = Rbf(x, y, tempu, function=function)
u = rbf(xi, yi)
rbf = Rbf(x, y, tempv, function=function)
v = rbf(xi, yi)
else:
xi = x
yi = y
u = tempu
v = tempv
self.barbs(xi, yi, u, v, **kwargs)
return self.axes[subplot_index]
