def test_resample_dtypes():
"""
Test if dtypes stay the same when resampling.
"""
data = {
'testint8': np.array([5, 5], dtype=np.int8),
'testfloat16': np.array([5, 5], dtype=np.float16)
}
fill_values = {'testint8': 0, 'testfloat16': 999.}
lons = np.array([0, 0.1])
lats = np.array([0, 0.1])
# lets resample to a 0.1 degree grid
# define the grid points in latitude and longitude
lats_dim = np.arange(-1, 1, 0.1)
lons_dim = np.arange(-1, 1, 0.1)
# make 2d grid out the 1D grid spacing
lons_grid, lats_grid = np.meshgrid(lons_dim, lats_dim)
resampled_data = resample.resample_to_grid(data,
lons,
lats,
lons_grid,
lats_grid,
fill_values=fill_values)
for key in data:
assert resampled_data[key].shape == lons_grid.shape
assert resampled_data[key].dtype == data[key].dtype
def test_resample_hamming():
"""
Test if hamming window is applied correctly
"""
# let's do 5 points with the highest value in the middle
# -1-
# 151
# -1-
data = {'testfloat16': np.array([1, 1, 5, 1, 1], dtype=np.float16)}
fill_values = {'testfloat16': 999.}
lons = np.array([0, -0.1, 0, 0.1, 0])
lats = np.array([0.1, 0, 0, 0, -0.1])
# lets resample to a 0.1 degree grid
# define the grid points in latitude and longitude
lats_dim = np.arange(-0.1, 0.11, 0.1)
lons_dim = np.arange(-0.1, 0.11, 0.1)
# make 2d grid out the 1D grid spacing
lons_grid, lats_grid = np.meshgrid(lons_dim, lats_dim)
# make partial function of the hamming window the radius of the hamming
# window is in meters not in degrees
hamm = functools.partial(resample.hamming_window, 15000)
resampled_data = resample.resample_to_grid(data,
lons,
lats,
lons_grid,
lats_grid,
fill_values=fill_values,
methods='custom',
weight_funcs=hamm)
resampled_should = np.array([[1.640625, 1.64160156, 1.640625],
[1.64160156, 3.11132812, 1.64160156],
[1.640625, 1.64160156, 1.640625]])
for key in data:
assert resampled_data[key].shape == lons_grid.shape
assert resampled_data[key].dtype == data[key].dtype
nptest.assert_almost_equal(resampled_data[key], resampled_should)
def test_resample_to_zero_dot_one_deg(self):
# lets resample to a 0.5 degree grid
# define the grid points in latitude and longitude
lats_dim = np.arange(0, 0.4, 0.1)
lons_dim = np.arange(0, 0.4, 0.1)
# make 2d grid out the 1D grid spacing
lons_grid, lats_grid = np.meshgrid(lons_dim, lats_dim)
resampled_data = resample.resample_to_grid(self.testdata,
self.lons,
self.lats,
lons_grid,
lats_grid,
search_rad=60000,
neighbours=1,
fill_values=np.nan)
for key in self.testdata:
assert resampled_data[key].shape == lons_grid.shape
assert np.all(np.all(resampled_data['ones'], 1))
assert np.all(
resampled_data['valrange'] == self.testdata['valrange'][90, 180])
def img_bulk(self):
"""
Yields numpy array of self.const.imgbuffer images,
start and enddate until all dates have been read
Returns
-------
img_stack_dict : dict of numpy.array
stack of daily images for each variable
startdate : date
date of first image in stack
enddate : date
date of last image in stack
datetimestack : np.array
array of the timestamps of each image
jd_stack : np.array or None
if None all observations in an image have the same
observation timestamp. Otherwise it gives the julian date
of each observation in img_stack_dict
"""
img_dict = {}
datetimes = []
jd_list = []
# set start of current imgbulk to startdate
bulkstart = self.startdate
# image counter
read_images = 0
dates = self.imgin.tstamps_for_daterange(self.startdate, self.enddate)
for date in dates:
try:
(input_img, metadata, image_datetime, lon, lat,
time_arr) = self.imgin.read(date, **self.input_kwargs)
except IOError as e:
msg = "I/O error({0}): {1}".format(e.errno, e.strerror)
logging.log(logging.INFO, msg)
continue
read_images += 1
logging.log(logging.INFO, "read" + image_datetime.isoformat())
if self.resample:
if time_arr is not None:
input_img['jd'] = time_arr
input_img = resamp.resample_to_grid(
input_img,
lon,
lat,
self.target_grid.activearrlon,
self.target_grid.activearrlat,
methods=self.r_methods,
weight_funcs=self.r_weightf,
min_neighbours=self.r_min_n,
search_rad=self.r_radius,
neighbours=self.r_neigh,
fill_values=self.r_fill_values)
time_arr = input_img.pop('jd')
if time_arr is None:
self.time_var = None
else:
self.time_var = 'jd'
if time_arr is not None:
# if time_var is not None means that each observation of the
# image has its own observation time
# this means that the resulting time series is not
# regularly spaced in time
if self.orthogonal is None:
self.orthogonal = False
if self.orthogonal:
raise Img2TsError(
"Images can not switch between a fixed image "
"timestamp and individual timestamps for each observation"
)
jd_list.append(time_arr)
if time_arr is None:
if self.orthogonal is None:
self.orthogonal = True
if not self.orthogonal:
raise Img2TsError(
"Images can not switch between a fixed image "
"timestamp and individual timestamps for each observation"
)
for key in input_img:
if key not in img_dict.keys():
img_dict[key] = []
img_dict[key].append(input_img[key])
datetimes.append(image_datetime)
if read_images >= self.imgbuffer - 1:
img_stack_dict = {}
if len(jd_list) != 0:
jd_stack = np.ma.vstack(jd_list)
jd_list = None
else:
jd_stack = None
for key in img_dict:
img_stack_dict[key] = np.vstack(img_dict[key])
img_dict[key] = None
datetimestack = np.array(datetimes)
img_dict = {}
datetimes = []
jd_list = []
yield (img_stack_dict, bulkstart, self.currentdate,
datetimestack, jd_stack)
# reset image counter
read_images = 0
if len(datetimes) > 0:
img_stack_dict = {}
if len(jd_list) != 0:
jd_stack = np.ma.vstack(jd_list)
else:
jd_stack = None
for key in img_dict:
img_stack_dict[key] = np.vstack(img_dict[key])
img_dict[key] = None
datetimestack = np.array(datetimes)
yield (img_stack_dict, bulkstart, self.currentdate, datetimestack,
jd_stack)