def extalg_plot(gi, imgkey=None):
gi.set_plotting_params(gi)
if imgkey and imgkey == 'rainrate':
colormapper = cm.ScalarMappable(norm=colors.NoNorm(), cmap=get_cmap('frozen_cmap'))
currimg = colormapper.to_rgba(normalize(gi.image['rainrate']['frozen']))
# imshow expects upside down arrays, but we should not store them upside down
# so flipud here
gi.basemap.imshow(np.flipud(gi.image['rainrate']['frozen']))
colormapper = cm.ScalarMappable(norm=colors.NoNorm(), cmap=get_cmap('liquid_cmap'))
currimg = colormapper.to_rgba(normalize(gi.image['rainrate']['liquid']))
# imshow expects upside down arrays, but we should not store them upside down
# so flipud here
gi.basemap.imshow(np.flipud(gi.image['rainrate']['liquid']))
##if 'float' in str(gi.image[imgkey].dtype):
## pass
##else:
## gi.image[imgkey].dtype = 'float64'
##gi.basemap.imshow(np.flipud(currimg), ax=gi.axes, interpolation='nearest')
if gi.is_final:
gi.finalize()
def extalg_plot(gi, imgkey=None):
gi.set_plotting_params(gi)
if imgkey and imgkey == 'rainrate':
colormapper = cm.ScalarMappable(norm=colors.NoNorm(),
cmap=get_cmap('frozen_cmap'))
currimg = colormapper.to_rgba(normalize(
gi.image['rainrate']['frozen']))
gi.basemap.imshow(gi.image['rainrate']['frozen'])
colormapper = cm.ScalarMappable(norm=colors.NoNorm(),
cmap=get_cmap('liquid_cmap'))
currimg = colormapper.to_rgba(normalize(
gi.image['rainrate']['liquid']))
gi.basemap.imshow(gi.image['rainrate']['liquid'])
##if 'float' in str(gi.image[imgkey].dtype):
## pass
##else:
## gi.image[imgkey].dtype = 'float64'
##gi.basemap.imshow(currimg, ax=gi.axes, interpolation='nearest')
if gi.is_final:
gi.finalize()
def image(self):
if not hasattr(self, '_image'):
img_dts = {}
pname = self.product.name
sname = self.sector.name
img_dts['start_fullsingleimg' + sname + pname] = datetime.utcnow()
log.info('Creating basic image.')
print_mem_usage(self.logtag + 'gimgbeforeregister', True)
#Register data to area definition
#Performing prior to color gun generation in order to allow
# for multiple data resolutions
gun = self.product.images['img']
img_dts['start_clrgunsingle' + sname + pname] = datetime.utcnow()
self._image = np.flipud(create_color_gun(self.registered_data,
gun))
img_dts['end_clrgunsingle' + sname + pname] = datetime.utcnow()
# add flexibility: if Boundary is added in the productfile.mxl
# the discrete colorbar is selected.
if len(self.product.colorbars
) > 0 and self.product.colorbars[0].norm == 'Boundary':
#ticks = [float(i) for i in self.product.colorbars[0].bounds.split(' ')]
#bounds = [ticks[0]-1] + ticks + [ticks[-1]+1]
colormapper = cm.ScalarMappable(norm=None,
cmap=get_cmap(
self.product.cmap))
else:
colormapper = cm.ScalarMappable(norm=colors.NoNorm(),
cmap=get_cmap(
self.product.cmap))
img_dts['start_torgbasingle' + sname + pname] = datetime.utcnow()
self._image = colormapper.to_rgba(self.image)
img_dts['end_torgbasingle' + sname + pname] = datetime.utcnow()
log.info(sname + pname + ' Done Creating single channel image.')
img_dts['end_fullsingleimg' + sname + pname] = datetime.utcnow()
for sttag in sorted(img_dts.keys()):
if 'start_' in sttag:
tag = sttag.replace('start_', '')
try:
log.info('process image time %-40s: ' % tag +
str(img_dts['end_' + tag] -
img_dts['start_' + tag]))
except:
log.info('WARNING! No end time for ' + sttag)
return self._image
def geo_stitched_plot(gi, imgkey=None):
if not imgkey:
return
if 'Infrared' in imgkey:
fg = gi.image[imgkey]
elif 'Visible' in imgkey:
fg = gi.image[imgkey]
log.info('Setting up fig and ax for dataset: %s' % (imgkey))
set_plotting_params(gi,
speed=None,
platform=None,
source=None,
prodname=imgkey,
bgname=None,
start_dt=None,
end_dt=None)
log.info('Plotting imgkey: %s' % (imgkey))
gi.basemap.imshow(fg,
ax=gi.axes,
cmap=get_cmap('Greys_r'),
interpolation='nearest')
if gi.is_final:
gi.finalize()
def plot(self):
#Figure and axes
self._figure, self._axes = self._create_fig_and_ax()
#self.axes.legend(loc=4,fontsize='small')
#colorlist=['fuchsia','lightcyan','turquoise','lightseagreen','springgreen',
# 'limegreen','green','yellow','tan','orange','chocolate','red','maroon','black']
#cmap = matplotlib.colors.ListedColormap(colorlist,N=len(colorlist))
if len(self.product.colorbars
) > 0 and self.product.colorbars[0].norm == 'Boundary':
cmap = self.product.cmap
ticks = [
float(i) for i in self.product.colorbars[0].bounds.split(' ')
]
bounds = [ticks[0] - 1] + ticks + [ticks[-1] + 1]
norm = colors.BoundaryNorm(bounds, get_cmap(self.product.cmap).N)
self.basemap.imshow(self.image,
ax=self.axes,
interpolation='nearest',
cmap=cmap,
norm=norm)
else:
self.basemap.imshow(self.image,
ax=self.axes,
interpolation='nearest')
if self.is_final:
self.finalize()
def __call__(self, df, prod, out=None):
# Make sure the data file only has one resolution of data
if len(df.datasets) != 1:
raise GIPlotError(
'More than one dataset encountered in data file.')
log.info('\tCreating image')
img = self.get_image(df, prod)
log.info('\tCreating figure and axes')
figsize = np.array(
(img.shape[1], img.shape[0])) / rcParams['figure.dpi']
fig = plt.figure(figsize=figsize)
ax = fig.add_axes((0, 0, 1, 1))
# Create alpha layer for RGB images
if img.ndim == 3:
alpha = np.array(~np.any(img.mask, axis=2), dtype=float)
img = np.dstack([img, alpha])
log.info('\tPlotting image on axes')
if prod.cmap:
cmap = get_cmap(prod.cmap)
else:
cmap = None
ax.imshow(img, vmin=0.0, vmax=1.0, cmap=cmap)
if out:
if not os.path.isdir(os.path.dirname(out)):
log.info('\tCreating output directory')
os.makedirs(os.path.dirname(out))
log.info('\tSaving image to {}'.format(out))
fig.savefig(out, interpolation=None, transparent=True)
log.info('\tSUCCESS')
if os.getenv('SLIDER2RSYNC') == 'True':
if prod.name in rsync.PRODUCT_MAP:
log.debug(
'Attempting to rsync {} imagery to slider2'.format(
prod.name))
rsync(out)
else:
log.debug('Product {} has no path for rsync.'.format(
prod.name))
return fig, ax
def image(self):
if not hasattr(self, '_image'):
img_dts = {}
pname = self.product.name
sname = self.sector.name
img_dts['start_fullsingleimg' + sname + pname] = datetime.utcnow()
log.info('Creating basic image.')
print_mem_usage(self.logtag + 'gimgbeforeregister', True)
#Register data to area definition
#Performing prior to color gun generation in order to allow
# for multiple data resolutions
gun = self.product.images['img']
img_dts['start_clrgunsingle' + sname + pname] = datetime.utcnow()
self._image = np.flipud(create_color_gun(self.registered_data,
gun))
img_dts['end_clrgunsingle' + sname + pname] = datetime.utcnow()
colormapper = cm.ScalarMappable(norm=colors.NoNorm(),
cmap=get_cmap(self.product.cmap))
img_dts['start_torgbasingle' + sname + pname] = datetime.utcnow()
self._image = colormapper.to_rgba(self.image)
img_dts['end_torgbasingle' + sname + pname] = datetime.utcnow()
log.info(sname + pname + ' Done Creating single channel image.')
img_dts['end_fullsingleimg' + sname + pname] = datetime.utcnow()
for sttag in sorted(img_dts.keys()):
if 'start_' in sttag:
tag = sttag.replace('start_', '')
try:
log.info('process image time %-40s: ' % tag +
str(img_dts['end_' + tag] -
img_dts['start_' + tag]) + ' ' +
socket.gethostname())
except:
log.info('WARNING! No end time for ' + sttag)
return self._image
def winds_plot(gi, imgkey=None):
df = gi.image[imgkey]['datafile']
ds = df.datasets[imgkey]
bgname = 'None'
prodname = imgkey
day_percent = None
if 'BACKGROUND' in gi.image[imgkey]:
bgfile = gi.image[imgkey]['BACKGROUND']
bgvarname = df.metadata['ds'][imgkey]['alg_channel']
bgvar = bgfile.variables[bgvarname]
lats = bgfile.geolocation_variables['Latitude']
lons = bgfile.geolocation_variables['Longitude']
sunzen = bgfile.geolocation_variables['SunZenith']
from .motion_config import motion_config
from geoips.geoalgs.lib.dataEnhancements import enhanceDataArrays
if bgvar.name not in motion_config(bgfile.source_name).keys():
log.warning('Variable %s not defined in motion_config for %s, can not find background, not plotting'%
(bgvar.name, bgfile.source_name))
return
config = motion_config(bgfile.source_name)[bgvar.name]
bgcmap = 'Greys'
if 'plot_params' in config.keys() \
and 'EnhImage' in config['plot_params'].keys() \
and 'cmap' in config['plot_params']['EnhImage'].keys():
bgcmap = config['plot_params']['EnhImage']['cmap']
bgvar, blah, blah2 = enhanceDataArrays(bgvar, config, sunzen1=sunzen)
chanstr = re.sub(r"^B","Channel ",bgvarname).replace('BT',' BT').replace('Ref',' Reflectance')
if bgvar.wavelength:
bgname = '%s - %s, %s um'%(bgvar.platform_name, chanstr, bgvar.wavelength)
else:
bgname = '%s - %s'%(bgvar.platform_name, chanstr)
if np.ma.count(bgvar):
try:
day_percent = (1.0 * np.ma.count(bgvar[ds.day_inds]) / np.ma.count(bgvar)) * 100
except KeyError:
pass
if gi.datafile.dataprovider is not None:
prodname = prodname+', '+gi.datafile.dataprovider
if day_percent is not None:
prodname = '%s Product: %d'%(prodname, day_percent) + '% day'
prodname = prodname.replace('_',' ')
log.info('Setting up fig and ax for dataset: %s with bgname: %s'%(prodname, bgname))
new_platform = gi.datafile.metadata['top']['alg_platform']
new_source = gi.datafile.metadata['top']['alg_source']
log.info('Plotting dataset: %s'%(imgkey))
qi = ds.variables['qis']
speed_kts = ms_to_kts(ds.variables['speed_ms'])
#good_inds = np.ma.where(qi>0.2)
good_inds = np.ma.where(speed_kts)
# Plot knots, store in text file as m/s
direction_deg = ds.variables['direction_deg'][good_inds]
speed_kts = speed_kts[good_inds]
u_kts, v_kts = spd2uv(speed_kts, direction_deg)
pres_mb = ds.variables['pres_mb'][good_inds]
lats = ds.variables['lats'][good_inds]
lons = ds.variables['lons'][good_inds]
if 'All_Pressure_Levels' in imgkey:
# color_levs = ['red','cyan','yellow','green','tan']
# pressure_levs = [0,400,600,800,950,1014]
color_levs = ['red', 'cyan', 'tan']
pressure_levs = [0, 400, 800, 1014]
[lats,lons,u_kts,v_kts] = get_pressure_levels(pres_mb, [lats,lons,u_kts,v_kts], pressure_levs)
# Note - if we set this to platform_display and source_display, the
# filenames will not reflect the actual satellite/sensor (winds/winds).
# But when it is set to platform/source, it actually changes the platform
# and source in the datafile, which breaks all subsequent sectors.
# So using set_winds_plotting_params to change source/platform
# FORCES a single sector. I'll have to look into whether there is
# an intelligent way to handle this. For now. One sector...
if speed_kts.shape[0] == 0:
log.warning('No valid winds, returning without attempting to plot')
return
if 'All_Pressure_Levels' in imgkey:
set_winds_plotting_params(gi, speed=None, pressure=pres_mb, altitude=None,
#platform_display=new_platform, source_display=new_source,
platform=new_platform, source=new_source,
prodname=prodname, bgname=bgname, listed_colormap_vals=color_levs,
ticks_vals=pressure_levs)
else:
set_winds_plotting_params(gi, speed_kts, None, None,
#platform_display=new_platform, source_display=new_source,
platform=new_platform, source=new_source,
prodname=prodname, bgname=bgname)
if 'BACKGROUND' in gi.image[imgkey]:
log.info('Plotting background image %s'%(bgname))
# np.flipud all data in the imshow step - as that is the only
# command that expects upside down arrays
gi.basemap.imshow(np.flipud(bgvar),ax=gi.axes,cmap=get_cmap(bgcmap))
'''
NOTE there appears to be an error in basemap - I had to add a try except to allow
for different outputs from np.where
4778 thresh = 360.-londiff_sort[-2] if nlons > 2 else 360.0 - londiff_sort[-1]
***4779 try:
***4780 itemindex = len(lonsin)-np.where(londiff>=thresh)[0][0]
***4781 except IndexError:
***4782 itemindex = len(lonsin)-np.where(londiff>=thresh)[0]
4783 else:
4784 itemindex = 0
4785
4786 if fix_wrap_around and itemindex:
4787 # check to see if cyclic (wraparound) point included
4788 # if so, remove it.
4789 if np.abs(lonsin[0]-lonsin[-1]) < 1.e-4:
4790 hascyclic = True
4791 lonsin_save = lonsin.copy()
4792 lonsin = lonsin[1:]
/satops/geoips_externals_nrl-2.7/built/anaconda2/lib/python2.7/site-packages/mpl_toolkits/basemap/__init__.py
'''
if 'All_Pressure_Levels' in imgkey:
log.info('Plotting all barbs with colors {} at pressure levels {}'.format(color_levs, pressure_levs))
# These are (potentially) stored in global lists of vectors - it just plots the ones with coverage in "barbs"
# Not sure how to tell quickly/easily a priori how many vectors will actually be plotted over a given
# sector. This is going to look way too dense on a global/large sector
# May be able to thin based on resolution of sector (basically, number of pixels per barb ?)
max_total_vecs = 12000
total_num_vecs = 0
for ulev in u_kts:
total_num_vecs += np.ma.count(ulev)
for (ulev,vlev,latlev,lonlev,colorlev) in zip(u_kts,v_kts,lats,lons, color_levs):
num_vecs = np.ma.count(ulev)
if num_vecs == 0:
log.info('Not plotting color {}, no winds'.format(colorlev))
continue
max_vecs = int(max_total_vecs * (1.0 * num_vecs / total_num_vecs))
log.info('Plotting color {0:<10}, number barbs {1}, max barbs of {2}'.format(
colorlev, num_vecs, max_vecs))
[lonlev, latlev, ulev, vlev] = thin_arrays(
num_vecs,
max_points=max_vecs,
arrs=[lonlev, latlev, ulev, vlev])
num_vecs = np.ma.count(ulev)
log.info(' new number barbs {}'.format(num_vecs))
gi.basemap.barbs(lonlev.data,latlev.data,
ulev,vlev,
color=colorlev,
ax=gi.axes,
#sizes=dict(height=0.8, spacing=0.3),
# height is length of flag on barb, as percentage of length
# spacing is spacing of flags on barb, as percentage of length of flag
sizes=dict(height=0.4, spacing=0.2),
linewidth=0.5,
# length is length of actual barb
length=5,
latlon=True)
else:
log.info('Plotting single level barbs with colorbars %s'%(gi.colorbars))
gi.basemap.barbs(lons.data,lats.data,
u_kts,v_kts,speed_kts,
ax=gi.axes,
cmap=gi.colorbars[0].cmap,
#sizes=dict(height=0.8, spacing=0.3),
sizes=dict(height=1, spacing=0.5),
norm=gi.colorbars[0].norm,
linewidth=0.5,
length=5,
#length=5,
latlon=True)
if gi.is_final:
gi.finalize()
def winds_plot(gi, imgkey=None):
df = gi.image[imgkey]['datafile']
ds = df.datasets[imgkey]
bgname = 'None'
prodname = imgkey
day_percent = None
if 'BACKGROUND' in gi.image[imgkey]:
bgfile = gi.image[imgkey]['BACKGROUND']
bgvarname = df.metadata['ds'][imgkey]['alg_channel']
bgvar = np.flipud(bgfile.variables[bgvarname])
lats = bgfile.geolocation_variables['Latitude']
lons = bgfile.geolocation_variables['Longitude']
sunzen = bgfile.geolocation_variables['SunZenith']
from .motion_config import motion_config
from .EnhancedImage import EnhancedImage
if bgvar.name not in motion_config(bgfile.source_name).keys():
log.warning(
'Variable %s not defined in motion_config for %s, can not find background, not plotting'
% (bgvar.name, bgfile.source_name))
return
config = motion_config(bgfile.source_name)[bgvar.name]
bgcmap = 'Greys'
if 'plot_params' in config.keys() \
and 'EnhImage' in config['plot_params'].keys() \
and 'cmap' in config['plot_params']['EnhImage'].keys():
bgcmap = config['plot_params']['EnhImage']['cmap']
enhdata = EnhancedImage(
bgvar,
bgvar.shape,
lats,
lons,
sunzen=sunzen,
)
enhdata.enhanceImage(config)
bgvar = enhdata.Data
chanstr = re.sub(r"^B", "Channel ",
bgvarname).replace('BT', ' BT').replace(
'Ref', ' Reflectance')
if bgvar.wavelength:
bgname = '%s - %s, %s um' % (bgvar.platform_name, chanstr,
bgvar.wavelength)
else:
bgname = '%s - %s' % (bgvar.platform_name, chanstr)
if np.ma.count(bgvar):
try:
day_percent = (1.0 * np.ma.count(bgvar[ds.day_inds]) /
np.ma.count(bgvar)) * 100
except KeyError:
pass
if gi.datafile.dataprovider is not None:
prodname = prodname + ', ' + gi.datafile.dataprovider
if day_percent is not None:
prodname = '%s Product: %d' % (prodname, day_percent) + '% day'
prodname = prodname.replace('_', ' ')
log.info('Setting up fig and ax for dataset: %s with bgname: %s' %
(prodname, bgname))
new_platform = gi.datafile.metadata['top']['alg_platform']
new_source = gi.datafile.metadata['top']['alg_source']
log.info('Plotting dataset: %s' % (imgkey))
resolution = min(gi.sector.area_info.proj4_pixel_width,
gi.sector.area_info.proj4_pixel_height)
direction = ds.variables['direction']
speed = ds.variables['speed']
u = speed * np.cos(np.radians(direction))
v = speed * np.sin(np.radians(direction))
pres = ds.variables['pres']
lats = ds.variables['lats']
lons = ds.variables['lons']
from geoips.geoalgs.lib.amv_plot import downsample_winds
from geoips.geoalgs.lib.amv_plot import set_winds_plotting_params
set_winds_plotting_params(gi, speed, None, None, new_platform, new_source,
prodname, bgname)
if 'BACKGROUND' in gi.image[imgkey]:
log.info('Plotting background image %s' % (bgname))
gi.basemap.imshow(bgvar, ax=gi.axes, cmap=get_cmap(bgcmap))
'''
NOTE there appears to be an error in basemap - I had to add a try except to allow
for different outputs from np.where
4778 thresh = 360.-londiff_sort[-2] if nlons > 2 else 360.0 - londiff_sort[-1]
***4779 try:
***4780 itemindex = len(lonsin)-np.where(londiff>=thresh)[0][0]
***4781 except IndexError:
***4782 itemindex = len(lonsin)-np.where(londiff>=thresh)[0]
4783 else:
4784 itemindex = 0
4785
4786 if fix_wrap_around and itemindex:
4787 # check to see if cyclic (wraparound) point included
4788 # if so, remove it.
4789 if np.abs(lonsin[0]-lonsin[-1]) < 1.e-4:
4790 hascyclic = True
4791 lonsin_save = lonsin.copy()
4792 lonsin = lonsin[1:]
/satops/geoips_externals_nrl-2.7/built/anaconda2/lib/python2.7/site-packages/mpl_toolkits/basemap/__init__.py
'''
log.info('Plotting barbs with colorbars %s' % (gi.colorbars))
gi.basemap.barbs(lons.data,
lats.data,
u,
v,
speed,
ax=gi.axes,
cmap=gi.colorbars[0].cmap,
sizes=dict(height=0.8, spacing=0.3),
norm=gi.colorbars[0].norm,
linewidth=2,
length=5,
latlon=True)
if gi.is_final:
gi.finalize()
def fields_plot(gi, imgkey=None):
if not imgkey:
return
varname, lev, sectname = imgkey.split('_')
prod_display_name = varname
if varname in prodnames.keys():
prod_display_name = prodnames[varname]
prodname = '{0} at {1} mb'.format(prod_display_name, lev)
bgname = None
dataset = gi.image[imgkey]
if varname == 'Winds':
log.info('Setting up fig and ax for dataset: %s with bgname: %s' %
(prodname, bgname))
u_kts = dataset.variables['uwind' + lev]
v_kts = dataset.variables['vwind' + lev]
numvecs = np.ma.count(u_kts)
maxvecs = 4000
speed_kts, direc_deg = uv2spd(u_kts, v_kts)
lons = dataset.geolocation_variables['Longitude']
lats = dataset.geolocation_variables['Latitude']
[u_kts, v_kts, lats, lons,
speed_kts] = thin_arrays(numvecs,
max_points=maxvecs,
arrs=[u_kts, v_kts, lats, lons, speed_kts])
set_winds_plotting_params(gi,
speed_kts,
pressure=None,
altitude=None,
platform=dataset.platform_name,
source=dataset.source_name,
prodname=prodname,
bgname=bgname,
start_dt=dataset.start_datetime,
end_dt=dataset.end_datetime,
ticks_vals=None,
listed_colormap_vals=None)
gi.basemap.barbs(lons.data,
lats.data,
u_kts,
v_kts,
speed_kts,
ax=gi.axes,
cmap=gi.colorbars[0].cmap,
sizes=dict(height=1, spacing=0.5),
norm=gi.colorbars[0].norm,
linewidth=0.5,
length=5,
latlon=True)
else:
set_winds_plotting_params(gi,
speed=None,
pressure=None,
altitude=None,
platform=dataset.platform_name,
source=dataset.source_name,
prodname=prodname,
bgname=bgname,
start_dt=dataset.start_datetime,
end_dt=dataset.end_datetime,
ticks_vals=None,
listed_colormap_vals=None)
cmapname = 'tropix_no_white'
plotdata = dataset.variables[varname + lev]
interp = 'sinc'
log.info('Using interpolation %s', interp)
# imshow expects upside down arrays
gi.basemap.imshow(np.flipud(plotdata),
ax=gi.axes,
cmap=get_cmap(cmapname),
interpolation=interp)
if gi.is_final:
gi.finalize()
