def resample_array(input_data, input_lat, input_lon, input_dict=None):
"""
Code snippets for resampling the input array on to a new grid, changing
the missing value or reducing the data type or floating point precision
of the array.
Edit the components of this routine for your particular needs. Just check
that input_data and output_data arrays are being used and referenced as
required.
"""
# Check missing value
# Some files gave an incorrect missing value, so we check for the
# actual missing value before using/replacing it.
checkfor = 99999.9
if np.sum(np.where(input_data==checkfor,1,0)) > input_data.size*0.7:
input_dict.update({'missing':checkfor})
# Copy dict
if input_dict is None:
output_dict = dict()
else:
output_dict = copy.deepcopy(input_dict)
# Output dimensions
(xs, xn, xc) = (112, 841, 0.05) # start, number, cellsize
(ys, yn, yc) = (-44, 681, 0.05) # start, number, cellsize
output_lon = nr.create_vector(xs, xn, xc)
output_lat = nr.create_vector(ys, yn, yc)
output_lat = output_lat[::-1] # reverse elements
# Create output array
output_data = np.zeros((output_lat.size,output_lon.size)) \
+ input_dict['missing']
# Copy data onto output grid
output_data = nr.copy_grids(input_data[0,:,:],input_lon,input_lat,
output_data,output_lon,output_lat)
output_data.shape = (1,yn,xn)
output_dict.update({'xmin':min(output_lon),
'xmax':max(output_lon),
'xstep':xc,
'xnum':xn,
'ymin':min(output_lat),
'ymax':max(output_lat),
'ystep':yc,
'ynum':yn,})
# Reduce precision of values to 1 decimal place and convert to f32
output_data = output_data.round(decimals=1)
output_data = np.float32(output_data)
output_dict.update({'datatype':'f4'})
# Change missing value
miss = -999.0
if input_dict['missing'] != miss:
output_data = nr.replace_values(output_data,input_dict['missing'],miss)
output_dict.update({'missing':miss})
return (output_data, output_lat, output_lon, output_dict)
def resample_array(input_data, input_lat, input_lon, input_dict=None):
"""
Code snippets for resampling the input array on to a new grid, changing
the missing value or reducing the data type or floating point precision
of the array.
Edit the components of this routine for your particular needs. Just check
that input_data and output_data arrays are being used and referenced as
required.
"""
# Copy dict
if input_dict is None:
output_dict = dict()
else:
output_dict = copy.deepcopy(input_dict)
# Output dimensions
(xs, xn, xc) = (112, 841, 0.05) # start, number, cellsize
(ys, yn, yc) = (-44, 681, 0.05) # start, number, cellsize
output_lon = nr.create_vector(xs, xn, xc)
output_lat = nr.create_vector(ys, yn, yc)
output_lat = output_lat[::-1] # reverse elements
# Create output array
output_data = np.zeros((output_lat.size,output_lon.size)) \
+ input_dict['missing']
# Copy data onto output grid
output_data = nr.copy_grids(input_data, input_lon, input_lat, output_data,
output_lon, output_lat)
output_dict.update({
'xmin': min(output_lon),
'xmax': max(output_lon),
'xstep': xc,
'xnum': xn,
'ymin': min(output_lat),
'ymax': max(output_lat),
'ystep': yc,
'ynum': yn,
})
# Reduce precision of values to 1 decimal place and convert to f32
output_data = input_data.round(decimals=1)
output_data = np.float32(input_data)
output_dict.update({'datatype': 'f4'})
# Change missing value
miss = -999
output_data = nr.replace_values(input_data, input_dict['missing'], miss)
output_dict.update({'missing': miss})
return (output_data, output_lat, output_lon, output_dict)
def resample_data(datarows,metalist):
"""
Convert a list of lists of (string) values to a 2D NumPy array. Create
dimension vectors based on extent and cell-size information in 'metalist'.
Create target dimension vectors based on pre-defined extents.
Check the correctness of the given missing value (in metalist) against
the data. Replace all missing values with a standard missing value.
Copy data from the input array to an output array defined by the
target dimension vectors. The precision of values in the output array are
reduced to 1 decimal place (for consistency). Return the output array,
target dimension vectors and a dict that gives the extents of the target
dimension vectors and the new missing value.
"""
# Parse metalist into a dict
meta = {y[0].lower():float(y[1]) for y in [x.split() for x in metalist]}
miss = -999.0
# ASCII dimensions
input_lon = nr.create_vector(meta['xllcorner']+meta['cellsize']/2.0, \
meta['ncols'], \
meta['cellsize'])
input_lat = nr.create_vector(meta['yllcorner']+meta['cellsize']/2.0, \
meta['nrows'], \
meta['cellsize'])
input_lat = input_lat[::-1] # reverse elements
# Output dimensions - not remapping, so commented out
#(xs, xn, xc) = (112, 841, 0.05) # start, number, cellsize
#(ys, yn, yc) = (-44, 681, 0.05) # start, number, cellsize
#output_lon = nr.create_vector(xs, xn, xc)
#output_lat = nr.create_vector(ys, yn, yc)
#output_lat = output_lat[::-1] # reverse elements
# Copy datarows into a 2D array
input_data = np.array(datarows,dtype=np.float64)
meta['nodata_value'] = \
check_bom_missing(input_data[0,:], 99999.9, meta['nodata_value'])
if meta['nodata_value']!=miss:
input_data = nr.replace_values(input_data,meta['nodata_value'],miss)
print "Replaced missing data %s with %s" % (meta['nodata_value'],miss)
# Create output array
#output_data = np.zeros((output_lat.size,output_lon.size))+miss
# Copy data onto output grid
#output_data = nr.copy_grids(input_data,input_lon,input_lat,
# output_data,output_lon,output_lat)
# Reduce precision of values to 1 decimal place and convert to f32
#output_data = output_data.round(decimals=1)
#output_data = np.float32(output_data)
input_data = input_data.round(decimals=1)
input_data = np.float32(input_data)
input_dict = {'xmin':min(input_lon).round(decimals=3),
'xmax':max(input_lon).round(decimals=3),
'xstep':meta['cellsize'],
'xnum':meta['ncols'],
'xunits':'degrees_east',
'ymin':min(input_lat).round(decimals=3),
'ymax':max(input_lat).round(decimals=3),
'ystep':meta['cellsize'],
'ynum':meta['nrows'],
'yunits':'degrees_north',
'missing':miss}
return (input_data, input_lat, input_lon, input_dict)
def resample_data(datarows, metalist):
"""
Convert a list of lists of (string) values to a 2D NumPy array. Create
dimension vectors based on extent and cell-size information in 'metalist'.
Create target dimension vectors based on pre-defined extents.
Check the correctness of the given missing value (in metalist) against
the data. Replace all missing values with a standard missing value.
Copy data from the input array to an output array defined by the
target dimension vectors. The precision of values in the output array are
reduced to 1 decimal place (for consistency). Return the output array,
target dimension vectors and a dict that gives the extents of the target
dimension vectors and the new missing value.
"""
# Parse metalist into a dict
meta = {y[0].lower(): float(y[1]) for y in [x.split() for x in metalist]}
miss = -999.0
# ASCII dimensions
input_lon = nr.create_vector(meta['xllcorner']+meta['cellsize']/2.0, \
meta['ncols'], \
meta['cellsize'])
input_lat = nr.create_vector(meta['yllcorner']+meta['cellsize']/2.0, \
meta['nrows'], \
meta['cellsize'])
input_lat = input_lat[::-1] # reverse elements
# Output dimensions - not remapping, so commented out
#(xs, xn, xc) = (112, 841, 0.05) # start, number, cellsize
#(ys, yn, yc) = (-44, 681, 0.05) # start, number, cellsize
#output_lon = nr.create_vector(xs, xn, xc)
#output_lat = nr.create_vector(ys, yn, yc)
#output_lat = output_lat[::-1] # reverse elements
# Copy datarows into a 2D array
input_data = np.array(datarows, dtype=np.float64)
meta['nodata_value'] = \
check_bom_missing(input_data[0,:], 99999.9, meta['nodata_value'])
if meta['nodata_value'] != miss:
input_data = nr.replace_values(input_data, meta['nodata_value'], miss)
print "Replaced missing data %s with %s" % (meta['nodata_value'], miss)
# Create output array
#output_data = np.zeros((output_lat.size,output_lon.size))+miss
# Copy data onto output grid
#output_data = nr.copy_grids(input_data,input_lon,input_lat,
# output_data,output_lon,output_lat)
# Reduce precision of values to 1 decimal place and convert to f32
#output_data = output_data.round(decimals=1)
#output_data = np.float32(output_data)
input_data = input_data.round(decimals=1)
input_data = np.float32(input_data)
input_dict = {
'xmin': min(input_lon).round(decimals=3),
'xmax': max(input_lon).round(decimals=3),
'xstep': meta['cellsize'],
'xnum': meta['ncols'],
'xunits': 'degrees_east',
'ymin': min(input_lat).round(decimals=3),
'ymax': max(input_lat).round(decimals=3),
'ystep': meta['cellsize'],
'ynum': meta['nrows'],
'yunits': 'degrees_north',
'missing': miss
}
return (input_data, input_lat, input_lon, input_dict)
