def get_nicenround_steps(cmap_limits, Nsteps = 10):
'''
Readjust given colormap limits in order to have
nice and rounded intervals between levels.
INPUT:
cmap_limits --- tuple of extend, min level, max level
Nsteps --- number of intervals in the colormap
OUTPUT:
tuple of extend, min level, max level, interval between level
'''
if cmap_limits[0] == 'both':
cmap_min, cmap_max, cmap_Nsteps = round_levels_with_zero_centred_between_two(
vmin0 = cmap_limits[1], vmax0 = cmap_limits[2], Nsteps0 = Nsteps)
cmap_step = (cmap_max - cmap_min) / cmap_Nsteps
return ('both', cmap_min, cmap_max, cmap_step)
elif cmap_limits[0] in ['min', 'max']:
extend, cmap_min, cmap_max = cmap_limits
rough_cmap_step = (cmap_max - cmap_min) / Nsteps
nice_cmap_step = muths.round_to_1(rough_cmap_step)
cmap_Nsteps = int(np.ceil((cmap_max - cmap_min) / nice_cmap_step))
if extend == 'min':
# align the top
nice_cmap_min = cmap_max - cmap_Nsteps * nice_cmap_step
return (extend, nice_cmap_min, cmap_max, nice_cmap_step)
elif extend == 'max':
# align the bottom
nice_cmap_max = cmap_min + cmap_Nsteps * nice_cmap_step
return (extend, cmap_min, nice_cmap_max, nice_cmap_step)
def symmetric_about_white_cmap_levels(rough_maxabs, Ncolours = 11):
'''
Returns min and max levels and step that will have 0 centred
on the colour white on a diverging colourmap that diverges from
the colour white
INPUT:
rough_maxabs -- rough maximum absolute value of the levels
(note the absolute value because max = -min
necessarily)
Ncolours -- number of intervals on the colour bar
'''
try:
assert Ncolours % 2 != 0
except AssertionError:
raise InputError('Number of colours needs to be an odd number.')
int_dv = muths.round_to_1(2 * rough_maxabs / Ncolours)
rough_dv = 2 * rough_maxabs / Ncolours
ddv = int_dv - rough_dv
maxabs = rough_maxabs + Ncolours / 2 * ddv
return (- maxabs, maxabs, int_dv)
def round_levels_with_zero_centred_between_two(vmin0 = -1, vmax0 = 2, Nsteps0 = 10):
'''
Suppose you want to divide the range (vmin0, vmax0) into roughly Nsteps0 intervals, where vmin0 < 0 < vmax0.
This function returns a new range(vmin, vmax) and new Nsteps that is
as close to the desired one as possible, but are such that dv = (vmax - vmin) / Nsteps
is a nice round value, and the value zero is centred on one of the Nsteps intervals.
INPUT:
vmin0 --- lower limit, must be negative.
vmax0 --- upper limit, must be positive.
Nsteps0 --- rough desired number of intervals between vmin0 and vmax0.
OUTPUT:
vmin --- lower limit
vmax --- upper limit
Nsteps --- number of intervals between vmin and vmax
'''
dv0 = (vmax0 - vmin0) / Nsteps0
dv = muths.round_to_1(dv0)
half_dv = .5 * dv
vmin = 0 - dv * int(np.ceil((0 - vmin0 - half_dv) / dv)) - half_dv
vmax = 0 + dv * int(np.ceil((vmax0 - 0 - half_dv) / dv)) + half_dv
Nsteps = int((vmax - vmin) / dv)
return (vmin, vmax, Nsteps)
