def interpolate_onto_grid(xy_vec, rasters, mx, my):
# Do the interpolation.
lndi, nndi = None, None
new_rasters = []
for raster in rasters:
if lndi is None:
lndi = LinearNDInterpolator(xy_vec, raster)
nndi = NearestNDInterpolator(xy_vec, raster)
else:
lndi = LinearNDInterpolator(lndi.tri, raster)
nndi.values = raster
new_raster = lndi(mx, my)
new_raster[np.isnan(new_raster)] = nndi(mx[np.isnan(new_raster)],
my[np.isnan(new_raster)])
new_rasters.append(new_raster)
return new_rasters
def interpolate_xarray_linear(xpoints,
ypoints,
values,
shape,
chunks=CHUNK_SIZE):
"""Interpolate linearly, generating a dask array."""
from scipy.interpolate.interpnd import (LinearNDInterpolator,
_ndim_coords_from_arrays)
if isinstance(chunks, (list, tuple)):
vchunks, hchunks = chunks
else:
vchunks, hchunks = chunks, chunks
points = _ndim_coords_from_arrays(
np.vstack((np.asarray(ypoints), np.asarray(xpoints))).T)
interpolator = LinearNDInterpolator(points, values)
grid_x, grid_y = da.meshgrid(da.arange(shape[1], chunks=hchunks),
da.arange(shape[0], chunks=vchunks))
# workaround for non-thread-safe first call of the interpolator:
interpolator((0, 0))
res = da.map_blocks(intp, grid_x, grid_y, interpolator=interpolator)
return DataArray(res, dims=('y', 'x'))
def interp_disp(disp):
# Based on monodepth/utils/evaluation_utils.py
J, I = np.meshgrid(np.arange(disp.shape[1]), np.arange(disp.shape[0]))
IJ = np.vstack([I.flatten(), J.flatten()]).T
d = disp[IJ[:, 0], IJ[:, 1]]
ij = IJ[d != 0, :]
d = d[d != 0]
intp = LinearNDInterpolator(ij, d, fill_value=0.)
disp_i = intp(IJ).reshape(disp.shape)
return disp_i
def get_environment_func(seconds, current_df):
# Создадим функцию интерполяции данных
day = 1 + floor(seconds / 86400)
if day > CACHE_INTERPOLATOR['last_day']:
logger.info('Интерполируем течения')
day_mask = current_df['time'] == day
xyz = np.array(current_df.loc[day_mask, ['x', 'y', 'depth']])
current_velocity = np.array(current_df.loc[day_mask, ['uo', 'vo']])
interpolator = LinearNDInterpolator(xyz, current_velocity)
CACHE_INTERPOLATOR['last_interpolator'] = interpolator
CACHE_INTERPOLATOR['last_day'] = day
else:
interpolator = CACHE_INTERPOLATOR['last_interpolator']
return interpolator
def execute(self):
foundation_func = LinearNDInterpolator(self.depth[:, 0:2],
self.depth[:, 2])
self.foundations = array([
foundation_func(self.wt_positions[i, 0], self.wt_positions[i, 1])
for i in range(self.wt_positions.shape[0])
])
#dist = DistFromBorders()(wt_positions=self.wt_positions, borders=self.borders).dist
min_depth = self.depth[:, 2].min()
self.foundations[isnan(self.foundations)] = min_depth
if self.scaling == 0.0:
# Using the baseline for scaling
self.scaling = sum(self.foundations)
self.foundation_length = sum(self.foundations) / self.scaling
def griddata(points, values, xi, method='linear', fill_value=np.nan, tol=1e-6):
"""modified griddata plus tol arg"""
points = _ndim_coords_from_arrays(points)
if points.ndim < 2:
ndim = points.ndim
else:
ndim = points.shape[-1]
if ndim == 1 and method in ('nearest', 'linear', 'cubic'):
from interpolate import interp1d
points = points.ravel()
if isinstance(xi, tuple):
if len(xi) != 1:
raise ValueError("invalid number of dimensions in xi")
xi, = xi
# Sort points/values together, necessary as input for interp1d
idx = np.argsort(points)
points = points[idx]
values = values[idx]
ip = interp1d(points,
values,
kind=method,
axis=0,
bounds_error=False,
fill_value=fill_value)
return ip(xi)
elif method == 'nearest':
ip = NearestNDInterpolator(points, values)
return ip(xi)
elif method == 'linear':
ip = LinearNDInterpolator(points, values, fill_value=fill_value)
return ip(xi)
elif method == 'cubic' and ndim == 2:
ip = CloughTocher2DInterpolator(points,
values,
fill_value=fill_value,
tol=tol)
return ip(xi)
else:
raise ValueError("Unknown interpolation method %r for "
"%d dimensional data" % (method, ndim))
def grid_interpolate_deconstructed(tri, values, grid_points, method='linear'):
"""
Underlying methods from scipy grid_data broken out to pass in the tri
values returned from qhull.Delaunay. This is done to improve the speed
of using grid_data
Args:
tri: values returned from qhull.Delaunay
values: values at HRRR stations generally
grid_points: tuple of vectors for X,Y coords of grid stations
method: either linear or cubic
Returns:
result of interpolation to gridded points
"""
if method == 'cubic':
return CloughTocher2DInterpolator(tri, values)(grid_points)
elif method == 'linear':
return LinearNDInterpolator(tri, values)(grid_points)
def _linear(self, dist, ix, n_interp, xi):
return LinearNDInterpolator(self.points[ix],
self.values[ix])(np.array([xi[n_interp]]))