def find_color_code_naive(h, s, b):
if check_gray(s, b):
return 'gray'
if check_black(s, b):
return 'black'
if check_white(s, b):
return 'white'
first = find_nearest_idx(HUE_TABLE.values(), h)
if b > BRIGHTNESS_IMPORTANCE_LEVEL:
logger.info('Brightness is important')
second = find_nearest_idx(SATURATION_TABLE, s)
else:
logger.info('Saturation is important')
second = find_nearest_idx(BRIGHTNESS_TABLE, b)
color = HSVColor(HUE_TABLE[first], SATURATION_TABLE[second]/100.0, BRIGHTNESS_TABLE[second]/100.0)
color = convert_color(color, sRGBColor)
return color.get_value_tuple(), (first, second)
def get_results(self, time_steps, result_key="output"):
"""
return results from storage for given time steps
:param time_steps: time points where values are demanded
:param result_key: type of values to be returned
"""
# TODO change to more uniform behaviour
idxs = np.array([find_nearest_idx(self._time_storage, t) for t in time_steps])
results = np.array(self._value_storage[result_key])[idxs]
if result_key == "output":
return EvalData([time_steps], results.flatten(), name=self.name)
else:
return results
def _update_plot(self):
"""
update plot window
"""
for idx, data_set in enumerate(self._data):
# find nearest time index
t_idx = ut.find_nearest_idx(self.time_data[idx], self._t)
# TODO draw grey line if value is outdated
# update data
self._plot_data_items[idx].setData(x=self.spatial_data[idx],
y=self.state_data[idx][t_idx])
self._time_text.setText('t= {0:.2f}'.format(self._t))
self._t += self._dt
if self._t > self._endtime:
self._t = 0
def __init__(self,grid_window=3, comp_method=['Rank'], field_weights=[],
lat_bounds=[], lon_bounds=[], forecast_lats=[], forecast_lons=[], lat_inc=1., lon_inc=1.,):
"""
Initialize the analog object.
:param grid_window:
integer, +/- number of grid points (n/s, e/w) around each forecast grid point
to include in local domain pattern matching.
For example, if grid_window = 3, we use 49 grid points
to calculate differences between forecast/training
data (3*2 + 1)*(3+2 +1).
:param comp_method
list, Method with which to pattern match. Options: ['Rank','MAE','RMSE',].
if n_vars > 1, can use different methods to compare each variable.
:param lat_bounds/lon_bounds:
list or NumPy array
A list/numpy array of all latitude within the forecast and training data.\n
len(allLats) = forecastData[0] or forecastData[1] if forecastData.shape == 3.
:param forecast_last/forecast_lons:
list or NumPy array
Either a list/numpy array of min/max forecast lats/lons (defining a domain) or a single point.
:param lat_inc/lon_inc:
float
The change in latitude/longitude each grid point (e.g. dx or dy).
:param forecast_dates:
float
The change in latitude/longitude each grid point (e.g. dx or dy).
:return: self
"""
# --- Here, we make sure the method(s) selected is/are available, and if it/they is/are then add
available_methods = ['rank','rmse','mae','corr',]
self.comp_method = []
for mthd in comp_method:
if any(mthd.lower() in avail for avail in available_methods):
self.comp_method.append(mthd.lower())
else:
warnings.warn('Method {} not an option! Reverting to rank method'.format(mthd.lower()))
self.comp_method.append('rank')
# --- Passed the check!
self.grid_window = grid_window
self.field_weights = field_weights
# --- Here, we check to make sure everything is copacetic with the domain specifications
# ---
if len(forecast_lats) != len(forecast_lons):
raise ValueError("len(lat_bounds) != len(lon_bounds)\nWe either need to forecast for a point or domain.")
# --- Everything cool? Ok, let's do this.
if len(forecast_lats) == 1:
self.point_fcst = True
else:
self.point_fcst = False
self.all_lats = np.arange(lat_bounds[0], lat_bounds[-1] + 1, lat_inc)
self.all_lons = np.arange(lon_bounds[0], lon_bounds[-1] + 1, lon_inc)
# --- If we're dealing with a point forecast, we will find the closest lat/lon grid points to the fcst point.
if len(forecast_lats) < 1:
self.closest_lat = self.all_lats[find_nearest_idx(self.all_lats[:], forecast_lats[0])]
self.closest_lon = self.all_lons[find_nearest_idx(self.all_lons[:], forecast_lons[0])]
# --- If not, we want to find a starting/stopping lat/lon indices to generate a domain-based forecast
else:
self.forecast_lats = forecast_lats
self.forecast_lons = forecast_lons
self.start_lat_idx = np.where(forecast_lats[0] == self.all_lats)[0]
self.start_lon_idx = np.where(forecast_lons[0] == self.all_lons)[0]
self.stop_lat_idx = np.where(forecast_lats[1] == self.all_lats)[0]
self.stop_lon_idx = np.where(forecast_lons[1] == self.all_lons)[0]
# --- Great, it passed! Let's add in some more info for our own edification
self.lat_bounds = lat_bounds
self.lon_bounds = lon_bounds
self.lat_inc = lat_inc
self.lon_inc = lon_inc
