def __init__(self, variable, levels=None):
super(LevelEditor, self).__init__()
layout = QtGui.QVBoxLayout()
self.set_title("%s Levels" % variable.id)
self.variable = variable
self._levels = levels
self.level_label = QtGui.QLabel()
def update_level_label(levels):
self.level_label.setText(repr(levels))
# Connect this to your object's signal
def set_levels(levels):
self.levels = levels
minval, maxval = vcs.minmax(variable)
if levels is None:
levels = vcs.utils.mkscale(*vcs.minmax(self.variable))
self.sliderWidget = SliderWidget.AdjustValues()
self.sliderWidget.update(minval, maxval, levels)
self.sliderWidget.valuesChanged.connect(set_levels)
self.levelsChanged.connect(update_level_label)
layout.addWidget(self.level_label)
layout.addWidget(self.sliderWidget)
self.setLayout(layout)
def numticks(self, num):
if num > 0:
# Interpolate between left and right num times
left, right = vcs.minmax(self.axis)
step = (right - left) / float(num)
self.ticks = {left + n * step: left + n * step for n in range(num)}
else:
left, right = vcs.minmax(self.axis)
step = (right - left) / float(num)
self.ticks = {right + n * step: right + n * step for n in range(-1 * num)}
def numticks(self, num):
if num > 0:
# Interpolate between left and right num times
left, right = vcs.minmax(self.axis)
step = (right - left) / float(num)
self.ticks = {left + n * step: left + n * step for n in range(num)}
else:
left, right = vcs.minmax(self.axis)
step = (right - left) / float(num)
self.ticks = {
right + n * step: right + n * step
for n in range(-1 * num)
}
def test1DMany(self):
d = numpy.sin(numpy.arange(100))
d = numpy.reshape(d, (10, 10))
one = self.x.create1d()
print("glob min mac::", vcs.minmax(d))
print("plt minmax: ", vcs.minmax(d[0]))
self.x.plot(d, one, bg=self.bg)
fnm = "test_vcs_1D_with_manyDs.png"
self.checkImage(fnm)
def step(self):
ticks = self.ticks
if isinstance(ticks, str):
ticks = vcs.elements["list"][ticks]
ticks = sorted(ticks)
left, right = vcs.minmax(self.axis)
return (right - left) / len(ticks)
def step(self):
ticks = self.ticks
if isinstance(ticks, str):
ticks = vcs.elements["list"][ticks]
ticks = sorted(ticks)
left, right = vcs.minmax(self.axis)
return (right - left) / len(ticks)
def levels(self):
if self._levels is None:
if self.variable is not None:
return vcs.utils.mkscale(*vcs.minmax(self.variable))
else:
self._levels = []
return self._levels
def _plotInternalCustomBoxfill(self):
"""Implements the logic to render a custom boxfill."""
self._mappers = []
self._customBoxfillArgs = self._prepContours()
tmpLevels = self._customBoxfillArgs["tmpLevels"]
tmpColors = self._customBoxfillArgs["tmpColors"]
tmpOpacities = self._customBoxfillArgs["tmpOpacities"]
style = self._gm.fillareastyle
luts = []
geos = []
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
_colorMap = self.getColorMap()
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels continues where one left off
# AND pattern is identical
# TODO this should really just be a single polydata/mapper/actor:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
# th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
th.SetInputData(self._vtkDataSetFittedToViewport)
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
# Make the polydata output available here for patterning later
geoFilter2.Update()
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color)
if style == 'solid':
tmpOpacity = tmpOpacities[j]
if tmpOpacity is None:
tmpOpacity = a / 100.
else:
tmpOpacity = tmpOpacities[j] / 100.
lut.SetTableValue(0, r / 100., g / 100., b / 100.,
tmpOpacity)
else:
lut.SetTableValue(0, 1., 1., 1., 0.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], False]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
self._mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
def gm(self, value):
self._gm = value
self.orig_levs = value.levels
if self.has_set_gm_levels() and self.var is not None:
levs = self._gm.levels
flat = self._var.flatten()
var_min, var_max = vcs.minmax(flat)
self.value_sliders.update(var_min, var_max, levs)
self.update_levels(levs, clear=True)
def _plotInternalCustomBoxfill(self):
"""Implements the logic to render a custom boxfill."""
self._mappers = []
self._customBoxfillArgs = self._prepContours()
tmpLevels = self._customBoxfillArgs["tmpLevels"]
tmpColors = self._customBoxfillArgs["tmpColors"]
tmpOpacities = self._customBoxfillArgs["tmpOpacities"]
style = self._gm.fillareastyle
luts = []
geos = []
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
_colorMap = self.getColorMap()
assert(style != 'solid' or len(tmpLevels) == 1)
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels continues where one left off
# AND pattern is identical
# TODO this should really just be a single polydata/mapper/actor:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
# Make the polydata output available here for patterning later
geoFilter2.Update()
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color)
if style == 'solid':
tmpOpacity = tmpOpacities[j]
if tmpOpacity is None:
tmpOpacity = a / 100.
else:
tmpOpacity = tmpOpacities[j] / 100.
lut.SetTableValue(0, r / 100., g / 100., b / 100., tmpOpacity)
else:
lut.SetTableValue(0, 1., 1., 1., 0.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], False]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
self._mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
def gm(self, value):
self._gm = value
self.orig_levs = value.levels
if self.has_set_gm_levels() and self.var is not None:
levs = self._gm.levels
flat = self._var.flatten()
var_min, var_max = vcs.minmax(flat)
self.value_sliders.update(var_min, var_max, levs)
self.update_levels(levs, clear=True)
def plot(self, data1, data2, tmpl, grid, transform, **kargs):
"""Overrides baseclass implementation."""
# Clear old results:
self._resultDict = {}
self._template = tmpl
self._originalData1 = data1
self._originalData2 = data2
self._vtkDataSet = grid
self._vtkGeoTransform = transform
# Preprocess the input scalar data:
self._updateScalarData()
self._min = self._data1.min()
self._max = self._data1.max()
self._scalarRange = vcs.minmax(self._data1)
# Create/update the VTK dataset.
plotBasedDualGrid = kargs.get('plot_based_dual_grid', True)
self._updateVTKDataSet(plotBasedDualGrid)
if (self._needsVectors):
vectors = self._vtkDataSet.GetPointData().GetVectors()
vectors.GetRange(self._vectorRange, -1)
# Update the results:
self._resultDict["vtk_backend_grid"] = self._vtkDataSet
self._resultDict["vtk_backend_geo"] = self._vtkGeoTransform
self._resultDict["vtk_backend_wrap"] = self._dataWrapModulo
self._resultDict["dataset_bounds"] = self._vtkDataSetBounds
# Determine and format the contouring information:
self._updateContourLevelsAndColors()
# Create the polydata filter:
self._vtkDataSetBoundsNoMask = self._vtkDataSet.GetBounds()
# Generate a mapper to render masked data:
self._createMaskedDataMapper()
self._createPolyDataFilter()
if (kargs.get('ratio', '0') == 'autot' and
# atot is implemented for linear plots at vcs level
# for geographic projections we implement it here.
self._vtkGeoTransform):
self._resultDict['ratio_autot_viewport'] = self._processRatioAutot(
self._template, self._vtkDataSet)
# Plot specific rendering:
self._plotInternal()
return self._resultDict
def run_minmax(inpath, varname, i):
mins = []
maxs = []
filedata = cdms2.open(inpath)
vardata = filedata[varname]
for step in range(vardata.shape[0]):
stepdata = vardata[step]
minmax = vcs.minmax(stepdata)
mins.append(minmax[0])
maxs.append(minmax[1])
return mins, maxs, i
def adjuster():
cdmsfile = cdms2.open(vcs.sample_data + "/clt.nc")
clt = cdmsfile("clt")
min, max = vcs.minmax(clt)
levels = vcs.utils.mkscale(*vcs.minmax(clt))
print len(levels)
edit = SliderWidget.AdjustValues()
edit.update(min, max, levels)
first = (edit, levels, min, max)
edit = SliderWidget.AdjustValues()
edit.update(min, max, levels)
new_vals = [1, 2, 5, 8, 20, 45, 70, 155, 139]
min = 0
max = 200
edit.update(min, max, new_vals)
second = (edit, new_vals, min, max)
return first, second
def levels(self):
"""Used internally, don't worry about it."""
levs = list(self._gm.levels)
# Check if they're autolevels
if numpy.allclose(levs, 1e20):
if vcs.isboxfill(self._gm) == 1:
nlevs = self.color_2 - self.color_1 + 1
minval, maxval = vcs.minmax(self._var)
levs = vcs.mkscale(minval, maxval)
if len(levs) == 1:
levs.append(levs[0] + .00001)
delta = (levs[-1] - levs[0]) / nlevs
levs = list(numpy.arange(levs[0], levs[-1] + delta, delta))
else:
levs = vcs.mkscale(*vcs.minmax(self._var))
# Now adjust for ext_1 nad ext_2
if self.ext_left:
levs.insert(0, -1e20)
if self.ext_right:
levs.append(1e20)
return levs
def levels(self):
"""Used internally, don't worry about it."""
levs = list(self._gm.levels)
# Check if they're autolevels
if numpy.allclose(levs, 1e20):
if vcs.isboxfill(self._gm) == 1:
nlevs = self.color_2 - self.color_1 + 1
minval, maxval = vcs.minmax(self._var)
levs = vcs.mkscale(minval, maxval)
if len(levs) == 1:
levs.append(levs[0] + .00001)
delta = (levs[-1] - levs[0]) / nlevs
levs = list(numpy.arange(levs[0], levs[-1] + delta, delta))
else:
levs = vcs.mkscale(*vcs.minmax(self._var))
# Now adjust for ext_1 nad ext_2
if self.ext_left:
levs.insert(0, -1e20)
if self.ext_right:
levs.append(1e20)
return levs
def var(self, value):
self._var = value
flat = self._var.flatten()
var_min, var_max = vcs.minmax(flat)
# Check if we're using auto levels
if self._gm is None or not self.has_set_gm_levels():
# Update the automatic levels with this variable
levs = vcs.utils.mkscale(var_min, var_max)
else:
# Otherwise, just use what the levels are
levs = self._gm.levels
self.canvas.clear()
self.value_sliders.update(var_min, var_max, levs)
self.update_levels(levs, clear=True)
def var(self, value):
self._var = value
flat = self._var.flatten()
var_min, var_max = vcs.minmax(flat)
# Check if we're using auto levels
if self._gm is None or not self.has_set_gm_levels():
# Update the automatic levels with this variable
levs = vcs.utils.mkscale(var_min, var_max)
else:
# Otherwise, just use what the levels are
levs = self._gm.levels
self.canvas.clear()
self.value_sliders.update(var_min, var_max, levs)
self.update_levels(levs, clear=True)
def set_anim_min_max(self):
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Note: cannot set the min and max values if the default graphics
# method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
if (do_min_max == 'yes'):
minv = []
maxv = []
if (self.create_params.a_min is None
or self.create_params.a_max is None):
for i in xrange(len(self.animate_info)):
minv.append(1.0e77)
maxv.append(-1.0e77)
for i in xrange(len(self.animate_info)):
dpy, slab = self.animate_info[i]
mins, maxs = vcs.minmax(slab)
minv[i] = float(numpy.minimum(float(minv[i]), float(mins)))
maxv[i] = float(numpy.maximum(float(maxv[i]), float(maxs)))
elif (isinstance(self.create_params.a_min, list)
or isinstance(self.create_params.a_max, list)):
for i in xrange(len(self.animate_info)):
try:
minv.append(self.create_params.a_min[i])
except:
minv.append(self.create_params.a_min[-1])
try:
maxv.append(self.create_params.a_max[i])
except:
maxv.append(self.create_params.a_max[-1])
else:
for i in xrange(len(self.animate_info)):
minv.append(self.create_params.a_min)
maxv.append(self.create_params.a_max)
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the data set will be used.
for i in xrange(len(self.animate_info)):
try:
self.set_animation_min_max(minv[i], maxv[i], i)
except Exception, err:
pass # if it is default, then you cannot set the min and max, so pass.
def plot(self, data1, data2, tmpl, grid, transform, **kargs):
"""Overrides baseclass implementation."""
# Clear old results:
self._resultDict = {}
self._template = tmpl
self._originalData1 = data1
self._originalData2 = data2
self._vtkDataSet = grid
self._vtkGeoTransform = transform
# Preprocess the input scalar data:
self._updateScalarData()
self._min = self._data1.min()
self._max = self._data1.max()
self._scalarRange = vcs.minmax(self._data1)
# Create/update the VTK dataset.
plotBasedDualGrid = kargs.get('plot_based_dual_grid', True)
self._updateVTKDataSet(plotBasedDualGrid)
# Update the results:
self._resultDict["vtk_backend_grid"] = self._vtkDataSet
self._resultDict["vtk_backend_geo"] = self._vtkGeoTransform
self._resultDict["vtk_backend_wrap"] = self._dataWrapModulo
self._resultDict["dataset_bounds"] = self._vtkDataSetBounds
# Determine and format the contouring information:
self._updateContourLevelsAndColors()
# Generate a mapper to render masked data:
self._createMaskedDataMapper()
# Create the polydata filter:
self._createPolyDataFilter()
if (kargs.get('ratio', '0') == 'autot' and
# atot is implemented for linear plots at vcs level
# for geographic projections we implement it here.
self._vtkGeoTransform):
self._resultDict['ratio_autot_viewport'] = self._processRatioAutot(
self._template, self._vtkDataSet)
# Plot specific rendering:
self._plotInternal()
return self._resultDict
def set_anim_min_max(self):
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Note: cannot set the min and max values if the default graphics
# method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
if ( do_min_max == 'yes' ):
minv = []
maxv=[]
if (self.create_params.a_min is None or
self.create_params.a_max is None):
for i in xrange(len(self.animate_info)):
minv.append( 1.0e77 )
maxv.append( -1.0e77 )
for i in xrange(len(self.animate_info)):
dpy, slab = self.animate_info[i]
mins, maxs = vcs.minmax(slab)
minv[i] = float(numpy.minimum(float(minv[i]), float(mins)))
maxv[i] = float(numpy.maximum(float(maxv[i]), float(maxs)))
elif (isinstance(self.create_params.a_min,list) or
isinstance(self.create_params.a_max,list)):
for i in xrange(len(self.animate_info)):
try:
minv.append( self.create_params.a_min[i] )
except:
minv.append( self.create_params.a_min[-1] )
try:
maxv.append( self.create_params.a_max[i] )
except:
maxv.append( self.create_params.a_max[-1] )
else:
for i in xrange(len(self.animate_info)):
minv.append( self.create_params.a_min )
maxv.append( self.create_params.a_max )
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the data set will be used.
for i in xrange(len(self.animate_info)):
try:
self.set_animation_min_max( minv[i], maxv[i], i )
except Exception,err:
pass # if it is default, then you cannot set the min and max, so pass.
def step(self, value):
left, right = vcs.minmax(self.axis)
tick_vals = []
value = float(value)
if value < 0:
cur_val = right
target = left
comp = target.__le__
else:
cur_val = left
target = right
comp = target.__ge__
while comp(cur_val):
tick_vals.append(cur_val)
cur_val += value
self.ticks = {i: i for i in tick_vals}
def step(self, value):
left, right = vcs.minmax(self.axis)
tick_vals = []
value = float(value)
if value < 0:
cur_val = right
target = left
comp = target.__le__
else:
cur_val = left
target = right
comp = target.__ge__
while comp(cur_val):
tick_vals.append(cur_val)
cur_val += value
self.ticks = {i: i for i in tick_vals}
def calculateStats(var):
"""Creates the statistical outputs needed."""
print "Taking ensemble average as main line, max, min as one lot and +/- standard dev as other."
cdms.setAutoBounds("on")
av=cdutil.averager(var, axis="1")
stddev=genutil.statistics.std(var, axis="1")
cdms.setAutoBounds("off")
maxList=[]
minList=[]
stddevUpper=[av[i]+stddev[i] for i in range(len(av))]
stddevLower=[av[i]-stddev[i] for i in range(len(av))]
for t in var:
(mini, maxi)=vcs.minmax(t)
minList.append(mini)
maxList.append(maxi)
return (av, maxList, minList, stddevUpper, stddevLower)
def plot(self, data1, data2, tmpl, gm, grid, transform):
"""Overrides baseclass implementation."""
# Clear old results:
self._resultDict = {}
self._gm = gm
self._template = tmpl
self._originalData1 = data1
self._originalData2 = data2
self._vtkDataSet = grid
self._vtkGeoTransform = transform
self._colorMap = \
vcs.elements["colormap"][self._context.canvas.getcolormapname()]
# Preprocess the input scalar data:
self._updateScalarData()
self._scalarRange = vcs.minmax(self._data1)
# Create/update the VTK dataset.
self._updateVTKDataSet()
# Update the results:
self._resultDict["vtk_backend_grid"] = self._vtkDataSet
self._resultDict["vtk_backend_geo"] = self._vtkGeoTransform
self._resultDict["vtk_backend_wrap"] = self._dataWrapModulo
# Determine and format the contouring information:
self._updateContourLevelsAndColors()
# Generate a mapper to render masked data:
self._createMaskedDataMapper()
# Create the polydata filter:
self._createPolyDataFilter()
# Plot specific rendering:
self._plotInternal()
return self._resultDict
def plot(self, data1, data2, tmpl, gm, grid, transform):
"""Overrides baseclass implementation."""
# Clear old results:
self._resultDict = {}
self._gm = gm
self._template = tmpl
self._originalData1 = data1
self._originalData2 = data2
self._vtkDataSet = grid
self._vtkGeoTransform = transform
self._colorMap = \
vcs.elements["colormap"][self._context.canvas.getcolormapname()]
# Preprocess the input scalar data:
self._updateScalarData()
self._scalarRange = vcs.minmax(self._data1)
# Create/update the VTK dataset.
self._updateVTKDataSet()
# Update the results:
self._resultDict["vtk_backend_grid"] = self._vtkDataSet
self._resultDict["vtk_backend_geo"] = self._vtkGeoTransform
self._resultDict["vtk_backend_wrap"] = self._dataWrapModulo
# Determine and format the contouring information:
self._updateContourLevelsAndColors()
# Generate a mapper to render masked data:
self._createMaskedDataMapper()
# Create the polydata filter:
self._createPolyDataFilter()
# Plot specific rendering:
self._plotInternal()
return self._resultDict
def testUpdateArray(self):
f = cdms2.open(
os.path.join(cdat_info.get_sampledata_path(),
"ta_ncep_87-6-88-4.nc"))
data = f("ta")
levels = vcs.mkscale(*vcs.minmax(data))
levels.insert(0, 1.e20)
levels.append(1.e20)
colors = vcs.getcolors(levels)
isof = vcs.createisofill()
isof.levels = levels
isof.fillareacolors = colors
isol = vcs.createisoline()
isol.levels = levels
tmpl = self.x.gettemplate("top_of2")
self.x.portrait()
self.x.plot(data, isof, tmpl)
tmpl = self.x.gettemplate("bot_of2")
disp = self.x.plot(data, isof, tmpl)
kw = {"time": slice(3, 4), "level": slice(6, 7)}
new = disp.array[0](**kw)
self.x.backend.update_input(disp.backend, new)
self.checkImage("test_vcs_update_array_extensions.png")
def plotminmax(outpath, mins, maxs, varname):
canvas = vcs.init()
gm = vcs.create1d()
mn, mx = vcs.minmax(mins, maxs)
gm.datawc_y1 = mn
gm.datawc_y2 = mx
template = vcs.createtemplate()
template.scale(.95)
template.move(.05, 'x')
template.blank(["max", "mean"])
canvas.plot(mins, gm, template, id=varname)
template = vcs.createtemplate()
template.scale(.95)
template.move(.05, 'x')
template.blank(["min", "mean"])
canvas.plot(maxs, gm, template, id=varname)
canvas.png(outpath)
canvas.clear()
def _plotInternal(self):
prepedContours = self._prepContours()
tmpLevels = prepedContours["tmpLevels"]
tmpIndices = prepedContours["tmpIndices"]
tmpColors = prepedContours["tmpColors"]
tmpOpacities = prepedContours["tmpOpacities"]
style = self._gm.fillareastyle
fareapixelspacing, fareapixelscale = self._patternSpacingAndScale()
mappers = []
luts = []
geos = []
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
plotting_dataset_bounds = self.getPlottingBounds()
x1, x2, y1, y2 = plotting_dataset_bounds
_colorMap = self.getColorMap()
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels contnues where one left off
# AND pattern is identical
# TODO this should really just be a single polydata that is
# colored by scalars:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
# Make the polydata output available here for patterning later
geoFilter2.Update()
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color)
if style == 'solid':
tmpOpacity = tmpOpacities[j]
if tmpOpacity is None:
tmpOpacity = a / 100.
else:
tmpOpacity = tmpOpacities[j] / 100.
lut.SetTableValue(0, r / 100., g / 100., b / 100.,
tmpOpacity)
else:
lut.SetTableValue(0, 1., 1., 1., 0.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], True]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
"""
numLevels = len(self._contourLevels)
if mappers == []: # ok didn't need to have special banded contours
mapper = vtk.vtkPolyDataMapper()
mappers = [mapper]
# Colortable bit
# make sure length match
while len(self._contourColors) < numLevels:
self._contourColors.append(self._contourColors[-1])
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(numLevels)
for i in range(numLevels):
r, g, b, a = self._colorMap.index[self._contourColors[i]]
lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.)
mapper.SetLookupTable(lut)
if numpy.allclose(self._contourLevels[0], -1.e20):
lmn = self._min - 1.
else:
lmn = self._contourLevels[0]
if numpy.allclose(self._contourLevels[-1], 1.e20):
lmx = self._max + 1.
else:
lmx = self._contourLevels[-1]
mapper.SetScalarRange(lmn, lmx)
self._resultDict["vtk_backend_luts"] = [[lut, [lmn, lmx, True]]]
"""
if self._maskedDataMapper is not None:
# Note that this is different for meshfill -- others prepend.
mappers.append(self._maskedDataMapper)
# Add a second mapper for wireframe meshfill:
if self._gm.mesh:
lineMappers = []
wireLUT = vtk.vtkLookupTable()
wireLUT.SetNumberOfTableValues(1)
wireLUT.SetTableValue(0, 0, 0, 0)
for polyMapper in mappers:
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(
polyMapper.GetInputConnection(0, 0))
lineMapper._useWireFrame = True
# 'noqa' comments disable pep8 checking for these lines. There
# is not a readable way to shorten them due to the unwieldly
# method name.
#
# Setup depth resolution so lines stay above points:
polyMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(
0, 1) # noqa
polyMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(
1, 1) # noqa
lineMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetLookupTable(wireLUT)
lineMappers.append(lineMapper)
mappers.extend(lineMappers)
# And now we need actors to actually render this thing
actors = []
vp = self._resultDict.get('ratio_autot_viewport', [
self._template.data.x1, self._template.data.x2,
self._template.data.y1, self._template.data.y2
])
dataset_renderer = None
xScale, yScale = (1, 1)
cti = 0
ctj = 0
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
wireframe = False
if hasattr(mapper, "_useWireFrame"):
prop = act.GetProperty()
prop.SetRepresentationToWireframe()
wireframe = True
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
dataset_renderer, xScale, yScale = self._context().fitToViewport(
act,
vp,
wc=plotting_dataset_bounds,
geoBounds=self._vtkDataSetBoundsNoMask,
geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=(dataset_renderer is None),
add_actor=(wireframe or (style == "solid")))
# TODO See comment in boxfill.
if mapper is self._maskedDataMapper:
actors.append(
[act, self._maskedDataMapper, plotting_dataset_bounds])
else:
actors.append([act, plotting_dataset_bounds])
if not wireframe:
# Since pattern creation requires a single color, assuming the
# first
if ctj >= len(tmpColors[cti]):
ctj = 0
cti += 1
c = self.getColorIndexOrRGBA(_colorMap,
tmpColors[cti][ctj])
# Get the transformed contour data
transform = act.GetUserTransform()
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(mapper.GetInput())
transformFilter.SetTransform(transform)
transformFilter.Update()
patact = fillareautils.make_patterned_polydata(
transformFilter.GetOutput(),
fillareastyle=style,
fillareaindex=tmpIndices[cti],
fillareacolors=c,
fillareaopacity=tmpOpacities[cti],
fillareapixelspacing=fareapixelspacing,
fillareapixelscale=fareapixelscale,
size=self._context().renWin.GetSize(),
renderer=dataset_renderer)
ctj += 1
if patact is not None:
actors.append([patact, plotting_dataset_bounds])
dataset_renderer.AddActor(patact)
t = self._originalData1.getTime()
if self._originalData1.ndim > 2:
z = self._originalData1.getAxis(-3)
else:
z = None
self._resultDict["vtk_backend_actors"] = actors
kwargs = {
"vtk_backend_grid": self._vtkDataSet,
"dataset_bounds": self._vtkDataSetBounds,
"plotting_dataset_bounds": plotting_dataset_bounds,
"vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask,
"vtk_backend_geo": self._vtkGeoTransform
}
if ("ratio_autot_viewport" in self._resultDict):
kwargs["ratio_autot_viewport"] = vp
self._resultDict.update(self._context().renderTemplate(
self._template,
self._data1,
self._gm,
t,
z,
X=numpy.arange(min(x1, x2),
max(x1, x2) * 1.1,
abs(x2 - x1) / 10.),
Y=numpy.arange(min(y1, y2),
max(y1, y2) * 1.1,
abs(y2 - y1) / 10.),
**kwargs))
legend = getattr(self._gm, "legend", None)
if self._gm.ext_1:
if isinstance(self._contourLevels[0], list):
if numpy.less(abs(self._contourLevels[0][0]), 1.e20):
# Ok we need to add the ext levels
self._contourLevels.insert(
0, [-1.e20, self._contourLevels[0][0]])
else:
if numpy.less(abs(self._contourLevels[0]), 1.e20):
# need to add an ext
self._contourLevels.insert(0, -1.e20)
if self._gm.ext_2:
if isinstance(self._contourLevels[-1], list):
if numpy.less(abs(self._contourLevels[-1][1]), 1.e20):
# need ext
self._contourLevels.append(
[self._contourLevels[-1][1], 1.e20])
else:
if numpy.less(abs(self._contourLevels[-1]), 1.e20):
# need exts
self._contourLevels.append(1.e20)
patternArgs = {}
patternArgs['style'] = self._gm.fillareastyle
patternArgs['index'] = self._gm.fillareaindices
if patternArgs['index'] is None:
patternArgs['index'] = [
1,
]
# Compensate for the different viewport size of the colorbar
patternArgs['opacity'] = self._gm.fillareaopacity
patternArgs['pixelspacing'] = [
int(fareapixelspacing[0] / (vp[1] - vp[0])),
int(fareapixelspacing[1] / (vp[3] - vp[2]))
]
patternArgs['pixelscale'] = fareapixelscale / (vp[1] - vp[0])
self._resultDict.update(self._context().renderColorBar(
self._template, self._contourLevels, self._contourColors, legend,
self.getColorMap(), **patternArgs))
if self._context().canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
continents_renderer, xScale, yScale = self._context(
).plotContinents(plotting_dataset_bounds, projection,
self._dataWrapModulo, vp,
self._template.data.priority, **kwargs)
def plot(self, data, template=None, bg=0, x=None, **kwargs):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template, str):
template = x.gettemplate(template)
elif not vcs.istemplate(template): # pragma: no cover
raise ValueError(
"Error did not know what to do with template: %s" %
template) # pragma: no cover
try:
data_name = data.title
except AttributeError:
try:
data_name = data.long_name
except AttributeError:
try:
data_name = data.id + data.units
except AttributeError:
try:
data_name = data.id
except AttributeError:
data_name = "array"
# We'll just flatten the data... if they want to be more precise,
# should pass in more precise data
if isinstance(data, cdms2.avariable.AbstractVariable):
data = data.asma()
data = data.flatten()
# ok now we have a good x and a good data
if not self.bins:
self.bins = vcs.utils.mkscale(*vcs.minmax(data))
# Sort the bins
self.bins.sort()
# Prune duplicates
pruned_bins = []
for bin in self.bins:
if pruned_bins and numpy.allclose(bin, pruned_bins[-1]):
continue
pruned_bins.append(bin)
self.bins = pruned_bins
data_bins = numpy.digitize(data, self.bins) - 1
binned = [data[data_bins == i] for i in range(len(self.bins))]
means = []
stds = []
max_possible_deviance = 0
for ind, databin in enumerate(binned):
if len(databin) > 0:
means.append(databin.mean())
stds.append(databin.std())
else:
means.append(0)
stds.append(0)
if len(self.bins) > ind + 1:
max_possible_deviance = max(means[ind] - self.bins[ind],
self.bins[ind + 1] - means[ind],
max_possible_deviance)
else:
max_possible_deviance = max(means[ind] - self.bins[ind],
max_possible_deviance)
color_values = [std / max_possible_deviance for std in stds]
y_values = [len(databin) for databin in binned]
nbars = len(self.bins) - 1
# create the primitive
fill = x.createfillarea()
line = x.createline()
fill.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
line.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
vcs_min_max = vcs.minmax(self.bins)
if numpy.allclose(self.datawc_x1, 1e20):
xmn = vcs_min_max[0]
else:
xmn = self.datawc_x1
if numpy.allclose(self.datawc_x2, 1e20):
xmx = vcs_min_max[1]
else:
xmx = self.datawc_x2
if numpy.allclose(self.datawc_y2, 1e20):
# Make the y scale be slightly larger than the largest bar
ymx = max(y_values) * 1.25
else:
ymx = self.datawc_y2
if numpy.allclose(self.datawc_y1, 1e20):
ymn = 0
else:
ymn = self.datawc_y1
fill.worldcoordinate = [xmn, xmx, ymn, ymx]
line.worldcoordinate = [xmn, xmx, ymn, ymx]
styles = []
cols = []
indices = []
lt = []
lw = []
lc = []
xs = []
ys = []
levels = [.1 * i for i in range(11)]
# Extend fillarea and line attrs to levels
if self.fillareastyles:
while len(self.fillareastyles) < (len(levels) - 1):
self.fillareastyles.append(self.fillareastyles[-1])
else:
self.fillareastyles = ["solid"] * (len(levels) - 1)
if self.fillareacolors:
while len(self.fillareacolors) < (len(levels) - 1):
self.fillareacolors.append(self.fillareacolors[-1])
else:
for lev in levels[:-1]:
self.fillareacolors.append(
int((self.color_2 - self.color_1) * lev) + self.color_1)
if self.fillareaindices:
while len(self.fillareaindices) < (len(levels) - 1):
self.fillareaindices.append(self.fillareaindices[-1])
else:
self.fillareaindices = [1] * (len(levels) - 1)
if self.line:
while len(self.line) < (len(levels) - 1):
self.line.append(self.line[-1])
else:
self.line = ["solid"] * (len(levels) - 1)
if self.linewidth:
while len(self.linewidth) < (len(levels) - 1):
self.linewidth.append(self.linewidth[-1])
else:
self.linewidth = [1] * (len(levels) - 1)
if self.linecolors:
while len(self.linecolors) < (len(levels) - 1):
self.linecolors.append(self.linecolors[-1])
else:
self.linecolors = ["black"] * (len(levels) - 1)
for i in range(nbars):
# Calculate level for bar
value = color_values[i]
for lev_ind in range(len(levels)):
if levels[lev_ind] > value:
if lev_ind > 0:
lev_ind -= 1
break
else:
# Shouldn't ever get here since level 0 is 0
assert False # pragma: no cover
else:
assert False # pragma: no cover
styles.append(self.fillareastyles[lev_ind])
cols.append(self.fillareacolors[lev_ind])
indices.append(self.fillareaindices[lev_ind])
lt.append(self.line[lev_ind])
lw.append(self.linewidth[lev_ind])
lc.append(self.linecolors[lev_ind])
xs.append([
self.bins[i], self.bins[i], self.bins[i + 1], self.bins[i + 1]
])
ys.append([0, y_values[i], y_values[i], 0])
fill.style = styles
fill.x = xs
fill.y = ys
fill.style
fill.index = indices
fill.color = cols
fill.colormap = self.colormap
line.x = xs
line.y = ys
line.type = lt
line.width = lw
line.color = lc
displays = []
x_axis = cdms2.createAxis(self.bins, id=data_name)
y_axis = cdms2.createAxis(vcs.mkscale(ymn, ymx), id="bin_size")
displays.append(x.plot(fill, bg=bg, render=False))
arr = MV2.masked_array(y_values)
arr.setAxis(0, x_axis)
dsp = template.plot(x, arr, self, bg=bg, X=x_axis, Y=y_axis)
for d in dsp:
if d is not None:
displays.append(d)
legend_labels = {
0: "No Variance",
.1: "",
.2: "",
.3: "",
.4: "",
.5: "",
.6: "",
.7: "",
.8: "",
.9: "",
1: "High Variance"
}
template.drawColorBar(self.fillareacolors,
levels,
legend=legend_labels,
x=x,
style=self.fillareastyles,
index=self.fillareaindices)
displays.append(x.plot(line, bg=bg))
x.worldcoordinate = fill.worldcoordinate
self.restore()
return displays
def create(self,
parent=None,
min=None,
max=None,
save_file=None,
thread_it=1,
rate=None,
bitrate=None,
ffmpegoptions=''):
from vcs import minmax
from numpy.ma import maximum, minimum
##from tkMessageBox import showerror
# Cannot "Run" or "Create" an animation while already creating an animation
if self.run_flg == 1: return
if self.vcs_self.canvas.creating_animation() == 1: return
if self.vcs_self.animate_info == []:
str = "No data found!"
showerror("Error Message to User", str)
return
finish_queued_X_server_requests(self.vcs_self)
self.vcs_self.canvas.BLOCK_X_SERVER()
# Stop the (thread) execution of the X main loop (if it is running).
self.vcs_self.canvas.stopxmainloop()
# Force VCS to update its orientation, needed when the user changes the
# VCS Canvas size.
self.vcs_self.canvas.updateorientation()
# Make sure the animate information is up-to-date for creating images
if ((self.gui_popup == 1) and (self.create_flg == 0)):
self.update_animate_display_list()
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Set up the animation min and max values by changing the graphics method
# Note: cannot set the min and max values if the default graphics method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
# Draw specified continental outlines if needed.
self.continents_hold_value = self.vcs_self.canvas.getcontinentstype()
self.vcs_self.canvas.setcontinentstype(self.continents_value)
if (do_min_max == 'yes'):
minv = []
maxv = []
if (min is None) or (max is None):
for i in range(len(self.vcs_self.animate_info)):
minv.append(1.0e77)
maxv.append(-1.0e77)
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
mins, maxs = minmax(slab)
minv[i] = float(minimum(float(minv[i]), float(mins)))
maxv[i] = float(maximum(float(maxv[i]), float(maxs)))
if isinstance(min, list) or isinstance(max, list):
for i in range(len(self.vcs_self.animate_info)):
try:
minv.append(min[i])
except:
minv.append(min[-1])
try:
maxv.append(max[i])
except:
maxv.append(max[-1])
else:
for i in range(len(self.vcs_self.animate_info)):
minv.append(min)
maxv.append(max)
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the data set will be used.
for i in range(len(self.vcs_self.animate_info)):
try:
self.set_animation_min_max(minv[i], maxv[i], i)
except Exception, err:
pass # if it is default, then you cannot set the min and max, so pass.
def plot(self,data=None,template = None, bg=0, x=None):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template,str):
template = x.gettemplate(template)
elif not vcs.istemplate(template):
raise "Error did not know what to do with template: %s" % template
if data.getLongitude() is None or data.getLatitude() is None:
raise Exception,["Error data do not have lat/lon"]
if data is None:
xmn=-180.
xmx=180
ymn=-90
ymx=90
else:
xmn,xmx = vcs.minmax(data.getLongitude()[:])
ymn,ymx = vcs.minmax(data.getLatitude()[:])
xmn,xmx,ymn,ymx = self.prep_plot(xmn,xmx,ymn,ymx)
n = len(self.sources)
for i in range(n):
type = self.types[i]
source = self.sources[i]
if type == 'ngdc' or type == 1:
fnm = self.gen_cont_file(xmn,xmx,ymn,ymx,source)
f=open(fnm)
data=f.read()
f.close()
if self.HAVE_BZ2:
import bz2
data = bz2.decompress(data)
elif type == "file" or type == 0:
source = self.sources[i]
f=open(source)
data=f.read()
f.close()
if fnm[-3:]=='bz2':
if self.HAVE_BZ2 :
import bz2
data = bz2.decompress(data)
else:
raise Excetpion, ["Cannot uncompress bzipped data"]
elif type == "shapefile" or type==2:
source = self.sources[i]
data = self.load_shapefile(source)
f = open(os.path.join(os.environ.get("HOME","."),"PCMDI_GRAPHICS","data_continent_other10"),"w")
f.write(data)
f.close()
c = x.createcontinents()
j=i
if i>=len(self.colors):
j=-1
c.linecolor=self.colors[j]
j=i
if i>=len(self.widths):
j=-1
c.linewidth=self.widths[j]
j=i
if i>=len(self.lines):
j=-1
c.line=self.lines[j]
c.type=10
c.datawc_x1 = xmn
c.datawc_x2 = xmx
c.datawc_y1 = ymn
c.datawc_y2 = ymx
c.xmtics1=self.xmtics1
c.xmtics2=self.xmtics2
c.ymtics1=self.ymtics1
c.ymtics2=self.ymtics2
c.xticlabels1=self.xticlabels1
c.xticlabels2=self.xticlabels2
c.yticlabels1=self.yticlabels1
c.yticlabels2=self.yticlabels2
c.xaxisconvert=self.xaxisconvert
c.yaxisconvert= self.yaxisconvert
c.legend = self.legend
c.projection=self.projection
self.x.plot(c,template,bg=bg)
def plot(self, data, template=None, bg=0, x=None, **kwargs):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template, str):
template = x.gettemplate(template)
elif not vcs.istemplate(template): # pragma: no cover
raise ValueError("Error did not know what to do with template: %s" % template) # pragma: no cover
try:
data_name = data.title
except AttributeError:
try:
data_name = data.long_name
except AttributeError:
try:
data_name = data.id + data.units
except AttributeError:
try:
data_name = data.id
except AttributeError:
data_name = "array"
# We'll just flatten the data... if they want to be more precise, should pass in more precise data
if isinstance(data, cdms2.avariable.AbstractVariable):
data = data.asma()
data = data.flatten()
# ok now we have a good x and a good data
if not self.bins:
self.bins = vcs.utils.mkscale(*vcs.minmax(data))
# Sort the bins
self.bins.sort()
# Prune duplicates
pruned_bins = []
for bin in self.bins:
if pruned_bins and numpy.allclose(bin, pruned_bins[-1]):
continue
pruned_bins.append(bin)
self.bins = pruned_bins
data_bins = numpy.digitize(data, self.bins) - 1
binned = [data[data_bins==i] for i in range(len(self.bins))]
means = []
stds = []
max_possible_deviance = 0
for ind, databin in enumerate(binned):
if len(databin) > 0:
means.append(databin.mean())
stds.append(databin.std())
else:
means.append(0)
stds.append(0)
if len(self.bins) > ind + 1:
max_possible_deviance = max(means[ind] - self.bins[ind], self.bins[ind + 1] - means[ind], max_possible_deviance)
else:
max_possible_deviance = max(means[ind] - self.bins[ind], max_possible_deviance)
color_values = [std / max_possible_deviance for std in stds]
y_values = [len(databin) for databin in binned]
nbars = len(self.bins) - 1
# create the primitive
fill = x.createfillarea()
line = x.createline()
fill.viewport = [
template.data.x1, template.data.x2, template.data.y1, template.data.y2]
line.viewport = [
template.data.x1, template.data.x2, template.data.y1, template.data.y2]
vcs_min_max = vcs.minmax(self.bins)
if numpy.allclose(self.datawc_x1, 1e20):
xmn = vcs_min_max[0]
else:
xmn = self.datawc_x1
if numpy.allclose(self.datawc_x2, 1e20):
xmx = vcs_min_max[1]
else:
xmx = self.datawc_x2
if numpy.allclose(self.datawc_y2, 1e20):
# Make the y scale be slightly larger than the largest bar
ymx = max(y_values) * 1.25
else:
ymx = self.datawc_y2
if numpy.allclose(self.datawc_y1, 1e20):
ymn = 0
else:
ymn = self.datawc_y1
fill.worldcoordinate = [xmn, xmx, ymn, ymx]
line.worldcoordinate = [xmn, xmx, ymn, ymx]
styles = []
cols = []
indices = []
lt = []
lw = []
lc = []
xs = []
ys = []
levels = [.1 * i for i in range(11)]
# Extend fillarea and line attrs to levels
if self.fillareastyles:
while len(self.fillareastyles) < (len(levels) - 1):
self.fillareastyles.append(self.fillareastyles[-1])
else:
self.fillareastyles = ["solid"] * (len(levels) - 1)
if self.fillareacolors:
while len(self.fillareacolors) < (len(levels) - 1):
self.fillareacolors.append(self.fillareacolors[-1])
else:
for lev in levels[:-1]:
self.fillareacolors.append(int((self.color_2 - self.color_1) * lev) + self.color_1)
if self.fillareaindices:
while len(self.fillareaindices) < (len(levels) - 1):
self.fillareaindices.append(self.fillareaindices[-1])
else:
self.fillareaindices = [1] * (len(levels) - 1)
if self.line:
while len(self.line) < (len(levels) - 1):
self.line.append(self.line[-1])
else:
self.line = ["solid"] * (len(levels) - 1)
if self.linewidth:
while len(self.linewidth) < (len(levels) - 1):
self.linewidth.append(self.linewidth[-1])
else:
self.linewidth = [1] * (len(levels) - 1)
if self.linecolors:
while len(self.linecolors) < (len(levels) - 1):
self.linecolors.append(self.linecolors[-1])
else:
self.linecolors = ["black"] * (len(levels) - 1)
for i in range(nbars):
# Calculate level for bar
value = color_values[i]
for lev_ind in range(len(levels)):
if levels[lev_ind] > value:
if lev_ind > 0:
lev_ind -= 1
break
else:
# Shouldn't ever get here since level 0 is 0
assert False # pragma: no cover
else:
assert False # pragma: no cover
styles.append(self.fillareastyles[lev_ind])
cols.append(self.fillareacolors[lev_ind])
indices.append(self.fillareaindices[lev_ind])
lt.append(self.line[lev_ind])
lw.append(self.linewidth[lev_ind])
lc.append(self.linecolors[lev_ind])
xs.append([self.bins[i], self.bins[i], self.bins[i + 1], self.bins[i + 1]])
ys.append([0, y_values[i], y_values[i], 0])
fill.style = styles
fill.x = xs
fill.y = ys
fill.style
fill.index = indices
fill.color = cols
fill.colormap = self.colormap
line.x = xs
line.y = ys
line.type = lt
line.width = lw
line.color = lc
displays = []
x_axis = cdms2.createAxis(self.bins, id=data_name)
y_axis = cdms2.createAxis(vcs.mkscale(ymn, ymx), id="bin_size")
displays.append(x.plot(fill, bg=bg, render=False))
arr = MV2.masked_array(y_values)
arr.setAxis(0, x_axis)
dsp = template.plot(x, arr, self, bg=bg, X=x_axis, Y=y_axis)
for d in dsp:
if d is not None:
displays.append(d)
legend_labels = {0: "No Variance",
.1: "",
.2: "",
.3: "",
.4: "",
.5: "",
.6: "",
.7: "",
.8: "",
.9: "",
1: "High Variance"}
template.drawColorBar(self.fillareacolors, levels,
legend=legend_labels, x=x,
style=self.fillareastyles,
index=self.fillareaindices)
displays.append(x.plot(line, bg=bg))
x.worldcoordinate = fill.worldcoordinate
self.restore()
return displays
def plot(self, data, data2, template=None, bg=0, x=None):
if x is None:
x = self.x
if template is None:
template = self.template
elif isinstance(template, str):
template = x.gettemplate(template)
elif not vcs.istemplate(template):
raise "Error did not know what to do with template: %s" % template
if not isinstance(data, cdms2.tvariable.TransientVariable):
mode = cdms2.getAutoBounds()
cdms2.setAutoBounds("on")
data = MV2.array(data)
data.getAxis(-1).getBounds()
cdms2.setAutoBounds(mode)
while data.ndim > 1:
data = data[0]
while data2.ndim > 1:
data2 = data2[0]
# ok now we have a good x and a good data
# create the primitive
fill = x.createfillarea()
line = x.createline()
fill.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
line.viewport = [
template.data.x1, template.data.x2, template.data.y1,
template.data.y2
]
ax = data.getAxis(0)[:]
ax2 = data.getAxis(0)[:]
xmn, xmx = vcs.minmax(ax, ax2)
ymn, ymx = vcs.minmax(data, data2)
xmn, xmx, ymn, ymx = self.prep_plot(xmn, xmx, ymn, ymx)
fill.worldcoordinate = [xmn, xmx, ymn, ymx]
line.worldcoordinate = [xmn, xmx, ymn, ymx]
fill.style = [
self.fillareastyle,
]
fill.color = [
self.fillareacolor,
]
fill.index = [
self.fillareaindex,
]
line.type = [
self.linetype,
]
line.width = [
self.linewidth,
]
line.color = [
self.linecolor,
]
xs = []
ys = []
xs = numpy.concatenate((ax[:], ax2[::-1])).tolist()
ys = numpy.concatenate((data[:], data2[::-1])).tolist()
xs.append(xs[0])
ys.append(ys[0])
fill.x = xs
fill.y = ys
line.x = xs
line.y = ys
displays = []
displays.append(x.plot(fill, bg=bg))
displays.append(x.plot(line, bg=bg))
x.worldcoordinate = fill.worldcoordinate
dsp = template.plot(x, data, self, bg=bg)
for d in dsp:
displays.append(d)
self.restore()
return displays
# Show fewer xticlabels in order to actually be able to read them
reduced_labels = vcs.createisofill("reduced", "default")
# You use a dictionary that maps values 0 <= x < 360 to strings
reduced_labels.xticlabels1 = {0: "0", 60: "60E", 120: "120E", 180: "180W",
240: "120W", 300: "60W", 360: "0"}
# isofill will use the naive minmax approach
isofill = vcs.createisofill("minmax", "reduced")
# Extract the minimum and maximum levels of sphu
# This will extract the minimum and maximum values from
# all time slices, which may be an issue for your dataset.
# If you want to do an animation, it's a good appraoch.
# If you're just looking at a single time slice, you're better off
# using our automatic level generator.
minval, maxval = vcs.minmax(sphu)
# Automatically create levels based on a minimum and maximum value
# It will round to surround the min and max
isofill.levels = vcs.mkscale(minval, maxval)
# Automatically retrieve colors for the scale
isofill.fillareacolors = vcs.getcolors(isofill.levels)
# isofill2 uses curated levels
# I used the built-in levels, took a look at the visualization, and selected
# the band of values that took up the most space in the heatmap.
isofill2 = vcs.createisofill("manual", "reduced")
isofill2.levels = vcs.mkscale(.2 * 10 ** -5, .5 * 10 ** -5)
# Since there are values outside of the upper and lower bounds I provided,
# let's turn on extensions to allow those values to be accomodated for.
isofill2.ext_1 = True
isofill2.ext_2 = True
def plot(self, var, theta=None, template=None, bg=0, x=None):
"""
Plots a polar plot of your data.
If var is an ndarray with the second dimension being 2, it will use the first value
as magnitude and the second as theta.
Otherwise, if theta is provided, it uses var as magnitude and the theta given.
"""
if x is None:
if self.x is None:
self.x = vcs.init()
x = self.x
if template is None:
template = self.template
if self.markercolorsource.lower() not in ("group", "magnitude",
"theta"):
raise ValueError(
"polar.markercolorsource must be one of: 'group', 'magnitude', 'theta'"
)
magnitudes, thetas, names = convert_arrays(var, theta)
if not self.negative_magnitude: # negative amplitude means 180 degree shift
neg = numpy.ma.less(magnitudes, 0.0)
magnitudes = numpy.ma.abs(magnitudes)
thetas = numpy.ma.where(neg, theta + numpy.pi, theta)
if self.group_names:
names = self.group_names
while len(names) < len(magnitudes):
names.append(None)
flat_magnitude = numpy.ravel(magnitudes)
canvas = x
# Determine aspect ratio for plotting the circle
canvas_info = canvas.canvasinfo()
# Calculate aspect ratio of window
window_aspect = canvas_info["width"] / float(canvas_info["height"])
if window_aspect > 1:
ymul = window_aspect
xmul = 1
else:
ymul = 1
xmul = window_aspect
# Use window_aspect to adjust size of template.data
x0, x1 = template.data.x1, template.data.x2
y0, y1 = template.data.y1, template.data.y2
xdiff = abs(x1 - x0)
ydiff = abs(y1 - y0)
center = x0 + xdiff / 2., y0 + ydiff / 2.
diameter = min(xdiff, ydiff)
radius = diameter / 2.
plot_kwargs = {"render": False, "bg": bg, "donotstoredisplay": True}
# Outer line
if template.box1.priority > 0:
outer = vcs.createline(source=template.box1.line)
x, y = circle_points(center, radius, ratio=window_aspect)
outer.x = x
outer.y = y
canvas.plot(outer, **plot_kwargs)
del vcs.elements["line"][outer.name]
if numpy.allclose((self.datawc_y1, self.datawc_y2), 1e20):
if self.magnitude_ticks == "*":
m_scale = vcs.mkscale(*vcs.minmax(flat_magnitude))
else:
if isinstance(self.magnitude_ticks, str):
ticks = vcs.elements["list"][self.magnitude_ticks]
else:
ticks = self.magnitude_ticks
m_scale = ticks
else:
m_scale = vcs.mkscale(self.datawc_y1, self.datawc_y2)
if template.ytic1.priority > 0:
m_ticks = vcs.createline(source=template.ytic1.line)
m_ticks.x = []
m_ticks.y = []
if template.ylabel1.priority > 0:
to = self.text_orientation_for_angle(
self.magnitude_tick_angle + self.theta_offset,
source=template.ylabel1.textorientation)
m_labels = self.create_text(template.ylabel1.texttable, to)
m_labels.x = []
m_labels.y = []
m_labels.string = []
if self.yticlabels1 == "*":
mag_labels = vcs.mklabels(m_scale)
else:
mag_labels = self.yticlabels1
else:
m_labels = None
for lev in m_scale:
lev_radius = radius * self.magnitude_from_value(lev, m_scale)
x, y = circle_points(center, lev_radius, ratio=window_aspect)
if m_labels is not None:
if lev in mag_labels:
m_labels.string.append(mag_labels[lev])
m_labels.x.append(xmul * lev_radius *
numpy.cos(self.magnitude_tick_angle +
self.theta_offset) +
center[0])
m_labels.y.append(ymul * lev_radius *
numpy.sin(self.magnitude_tick_angle +
self.theta_offset) +
center[1])
m_ticks.x.append(x)
m_ticks.y.append(y)
canvas.plot(m_ticks, **plot_kwargs)
del vcs.elements["line"][m_ticks.name]
if m_labels is not None:
canvas.plot(m_labels, **plot_kwargs)
del vcs.elements["textcombined"][m_labels.name]
if template.ymintic1.priority > 0 and self.magnitude_mintics is not None:
mag_mintics = vcs.createline(source=template.ymintic1.line)
mag_mintics.x = []
mag_mintics.y = []
mintics = self.magnitude_mintics
if isinstance(mintics, str):
mintics = vcs.elements["list"][mintics]
for mag in mintics:
mintic_radius = radius * \
self.magnitude_from_value(mag, m_scale)
x, y = circle_points(center,
mintic_radius,
ratio=window_aspect)
mag_mintics.x.append(x)
mag_mintics.y.append(y)
canvas.plot(mag_mintics, **plot_kwargs)
del vcs.elements["line"][mag_mintics.name]
if self.xticlabels1 == "*":
if numpy.allclose((self.datawc_x1, self.datawc_x2), 1e20):
tick_thetas = list(numpy.arange(0, numpy.pi * 2, numpy.pi / 4))
tick_labels = {t: str(t) for t in tick_thetas}
else:
d_theta = (self.datawc_x2 - self.datawc_x1) / \
float(self.theta_tick_count)
tick_thetas = numpy.arange(self.datawc_x1,
self.datawc_x2 + .0001, d_theta)
tick_labels = vcs.mklabels(tick_thetas)
else:
tick_thetas = sorted(list(self.xticlabels1.keys()))
tick_labels = self.xticlabels1
if template.xtic1.priority > 0:
t_ticks = vcs.createline(source=template.xtic1.line)
t_ticks.x = []
t_ticks.y = []
if template.xlabel1.priority > 0:
t_labels = []
theta_labels = tick_labels
else:
t_labels = None
for t in tick_thetas:
angle = self.theta_from_value(t)
x0 = center[0] + (xmul * radius * numpy.cos(angle))
x1 = center[0]
y0 = center[1] + (ymul * radius * numpy.sin(angle))
y1 = center[1]
if t_labels is not None:
label = self.create_text(
template.xlabel1.texttable,
self.text_orientation_for_angle(
angle, source=template.xlabel1.textorientation))
label.string = [theta_labels[t]]
label.x = [x0]
label.y = [y0]
t_labels.append(label)
t_ticks.x.append([x0, x1])
t_ticks.y.append([y0, y1])
canvas.plot(t_ticks, **plot_kwargs)
del vcs.elements["line"][t_ticks.name]
if t_labels is not None:
for l in t_labels:
canvas.plot(l, **plot_kwargs)
del vcs.elements["textcombined"][l.name]
values = vcs.createmarker()
values.type = self.markertypes
values.size = self.markersizes
values.color = self.markercolors
values.colormap = self.colormap
values.priority = self.markerpriority
values.x = []
values.y = []
if template.legend.priority > 0:
# Only labels that are set will show up in the legend
label_count = len(names) - len([i for i in names if i is None])
labels = self.create_text(template.legend.texttable,
template.legend.textorientation)
labels.x = []
labels.y = []
labels.string = []
if self.linepriority > 0:
line = vcs.createline()
line.x = []
line.y = []
line.type = self.linetypes
line.color = self.linecolors if self.linecolors is not None else self.markercolors
line.width = self.linewidths
line.priority = self.linepriority
# This is up here because when it's part of the main loop, we can
# lose "order" of points when we flatten them.
for mag, theta in zip(magnitudes, thetas):
x = []
y = []
for m, t in zip(mag, theta):
t = self.theta_from_value(t)
r = self.magnitude_from_value(m, m_scale) * radius
if r == numpy.nan:
continue
x.append(xmul * numpy.cos(t) * r + center[0])
y.append(ymul * numpy.sin(t) * r + center[1])
if self.connect_groups:
line.x.extend(x)
line.y.extend(y)
else:
line.x.append(x)
line.y.append(y)
if self.markercolorsource.lower() in ('magnitude', "theta"):
# Regroup the values using the appropriate metric
mag_flat = numpy.array(magnitudes).flatten()
theta_flat = numpy.array(thetas).flatten()
if self.markercolorsource.lower() == "magnitude":
scale = m_scale
vals = mag_flat
else:
scale = tick_thetas
vals = theta_flat
indices = [
numpy.where(
numpy.logical_and(vals >= scale[i], vals <= scale[i + 1]))
for i in range(len(scale) - 1)
]
magnitudes = [mag_flat[inds] for inds in indices]
thetas = [theta_flat[inds] for inds in indices]
names = vcs.mklabels(scale, output="list")
names = [
names[i] + " - " + names[i + 1] for i in range(len(names) - 1)
]
label_count = len(names)
for mag, theta, name in zip(magnitudes, thetas, names):
x = []
y = []
for m, t in zip(mag, theta):
t = self.theta_from_value(t)
r = self.magnitude_from_value(m, m_scale) * radius
x.append(xmul * numpy.cos(t) * r + center[0])
y.append(ymul * numpy.sin(t) * r + center[1])
if template.legend.priority > 0 and name is not None:
y_offset = len(labels.x) / float(label_count) * \
(template.legend.y2 - template.legend.y1)
lx, ly = template.legend.x1, template.legend.y1 + y_offset
x.append(lx)
y.append(ly)
labels.x.append(lx + .01)
labels.y.append(ly)
labels.string.append(str(name))
values.x.append(x)
values.y.append(y)
if template.legend.priority > 0:
canvas.plot(labels, **plot_kwargs)
del vcs.elements["textcombined"][labels.name]
if self.linepriority > 0:
canvas.plot(line, **plot_kwargs)
del vcs.elements["line"][line.name]
for el in self.to_cleanup:
if vcs.istexttable(el):
if el.name in vcs.elements["texttable"]:
del vcs.elements["texttable"][el.name]
else:
if el.name in vcs.elements["textorientation"]:
del vcs.elements["textorientation"][el.name]
self.to_cleanup = []
# Prune unneeded levels from values
to_prune = []
for ind, (x, y) in enumerate(zip(values.x, values.y)):
if x and y:
continue
else:
to_prune.append(ind)
for prune_ind in to_prune[::-1]:
del values.x[prune_ind]
del values.y[prune_ind]
if len(values.color) > prune_ind and len(values.color) > 1:
del values.color[prune_ind]
if len(values.size) > prune_ind and len(values.size) > 1:
del values.size[prune_ind]
if len(values.type) > prune_ind and len(values.type) > 1:
del values.type[prune_ind]
canvas.plot(values, bg=bg, donotstoredisplay=True)
del vcs.elements["marker"][values.name]
return canvas
def create(self, parent=None, min=None, max=None, save_file=None,
thread_it=1, rate=None, bitrate=None, ffmpegoptions=''):
from vcs import minmax
from numpy.ma import maximum, minimum
# Cannot "Run" or "Create" an animation while already creating an
# animation
if self.run_flg == 1:
return
if self.vcs_self.canvas.creating_animation() == 1:
return
if self.vcs_self.animate_info == []:
str = "No data found!"
showerror("Error Message to User", str)
return
# Stop the (thread) execution of the X main loop (if it is running).
self.vcs_self.canvas.stopxmainloop()
# Force VCS to update its orientation, needed when the user changes the
# VCS Canvas size.
self.vcs_self.canvas.updateorientation()
# Make sure the animate information is up-to-date for creating images
if ((self.gui_popup == 1) and (self.create_flg == 0)):
self.update_animate_display_list()
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Set up the animation min and max values by changing the graphics method
# Note: cannot set the min and max values if the default graphics
# method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
# Draw specified continental outlines if needed.
self.continents_hold_value = self.vcs_self.canvas.getcontinentstype()
self.vcs_self.canvas.setcontinentstype(self.continents_value)
if (do_min_max == 'yes'):
minv = []
maxv = []
if (min is None) or (max is None):
for i in range(len(self.vcs_self.animate_info)):
minv.append(1.0e77)
maxv.append(-1.0e77)
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
mins, maxs = minmax(slab)
minv[i] = float(minimum(float(minv[i]), float(mins)))
maxv[i] = float(maximum(float(maxv[i]), float(maxs)))
if isinstance(min, list) or isinstance(max, list):
for i in range(len(self.vcs_self.animate_info)):
try:
minv.append(min[i])
except:
minv.append(min[-1])
try:
maxv.append(max[i])
except:
maxv.append(max[-1])
else:
for i in range(len(self.vcs_self.animate_info)):
minv.append(min)
maxv.append(max)
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the
# data set will be used.
for i in range(len(self.vcs_self.animate_info)):
try:
self.set_animation_min_max(minv[i], maxv[i], i)
except:
# if it is default, then you cannot set the min and max, so
# pass.
pass
if save_file is None or save_file.split('.')[-1].lower() == 'ras':
if thread_it:
thread.start_new_thread(
self.vcs_self.canvas.animate_init, (save_file,))
else:
self.vcs_self.canvas.animate_init(save_file)
else: # ffmpeg stuff
save_info = self.vcs_self.animate_info
animation_info = self.animate_info_from_python()
slabs = []
templates = []
dpys = []
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
slabs.append(slab)
dpys.append(dpy)
templates.append(dpy.template)
sh = slabs[0].shape
if dpy.g_type in ['boxfill', 'isofill', 'isoline', 'meshfill',
'outfill', 'outline', 'taylordiagram', 'vector', ]:
r = len(sh) - 2
else:
r = len(sh) - 1
# now create the list of all previous indices to plot
indices = []
for i in range(r):
this = list(range(sh[i]))
tmp = []
if indices == []:
for k in this:
indices.append([k, ])
else:
for j in range(len(indices)):
for k in this:
tmp2 = copy.copy(indices[j])
tmp2.append(k)
tmp.append(tmp2)
indices = tmp
count = 1
white_square = self.vcs_self.createfillarea()
white_square.color = 240
white_square.x = [0, 1, 1, 0]
white_square.y = [0, 0, 1, 1]
new_vcs = self.vcs_self
if self.vcs_self.orientation() == 'portrait':
new_vcs.portrait()
# self.vcs_self.close()
for index in indices:
new_vcs.clear()
new_vcs.plot(white_square, bg=1)
for i in range(len(save_info)):
slab = slabs[i]
template = templates[i]
gtype = animation_info["gtype"][i].lower()
gname = animation_info["gname"][i]
gm = None # for flake8 to be happy
exec("gm = new_vcs.get%s('%s')" % (gtype, gname))
for j in index:
slab = slab[j]
new_vcs.plot(slab, gm, new_vcs.gettemplate(template), bg=1)
new_vcs.png("tmp_anim_%i" % count)
count += 1
new_vcs.ffmpeg(
save_file,
"tmp_anim_%d.png",
bitrate=bitrate,
rate=rate,
options=ffmpegoptions)
for i in range(count - 1):
os.remove("tmp_anim_%i.png" % (i + 1))
del(new_vcs)
self.create_flg = 1
def create( self, parent=None, min=None, max=None, save_file=None, thread_it = 1, rate=None, bitrate=None, ffmpegoptions='' ):
from vcs import minmax
from numpy.ma import maximum,minimum
##from tkMessageBox import showerror
# Cannot "Run" or "Create" an animation while already creating an animation
if self.run_flg == 1: return
if self.vcs_self.canvas.creating_animation() == 1: return
if self.vcs_self.animate_info == []:
str = "No data found!"
showerror( "Error Message to User", str )
return
finish_queued_X_server_requests( self.vcs_self )
self.vcs_self.canvas.BLOCK_X_SERVER()
# Stop the (thread) execution of the X main loop (if it is running).
self.vcs_self.canvas.stopxmainloop( )
# Force VCS to update its orientation, needed when the user changes the
# VCS Canvas size.
self.vcs_self.canvas.updateorientation()
# Make sure the animate information is up-to-date for creating images
if ((self.gui_popup == 1) and (self.create_flg == 0)):
self.update_animate_display_list( )
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Set up the animation min and max values by changing the graphics method
# Note: cannot set the min and max values if the default graphics method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
# Draw specified continental outlines if needed.
self.continents_hold_value = self.vcs_self.canvas.getcontinentstype( )
self.vcs_self.canvas.setcontinentstype( self.continents_value )
if ( do_min_max == 'yes' ):
minv = []
maxv=[]
if (min is None) or (max is None):
for i in range(len(self.vcs_self.animate_info)):
minv.append( 1.0e77 )
maxv.append( -1.0e77 )
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
mins, maxs = minmax(slab)
minv[i] = float(minimum(float(minv[i]), float(mins)))
maxv[i] = float(maximum(float(maxv[i]), float(maxs)))
if isinstance(min,list) or isinstance(max,list):
for i in range(len(self.vcs_self.animate_info)):
try:
minv.append( min[i] )
except:
minv.append( min[-1] )
try:
maxv.append( max[i] )
except:
maxv.append( max[-1] )
else:
for i in range(len(self.vcs_self.animate_info)):
minv.append( min )
maxv.append( max )
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the data set will be used.
for i in range(len(self.vcs_self.animate_info)):
try:
self.set_animation_min_max( minv[i], maxv[i], i )
except Exception,err:
pass # if it is default, then you cannot set the min and max, so pass.
def return_animation_min_max(self):
dpy, slab = self.vcs_self.animate_info[0]
return vcs.minmax(slab)
def _plotInternal(self):
tmpLevels = []
tmpColors = []
indices = self._gm.fillareaindices
if indices is None:
indices = [1]
while len(indices) < len(self._contourColors):
indices.append(indices[-1])
if len(self._contourLevels) > len(self._contourColors):
raise RuntimeError(
"You asked for %i levels but provided only %i colors\n"
"Graphic Method: %s of type %s\nLevels: %s"
% (len(self._contourLevels), len(self._contourColors),
self._gm.name, self._gm.g_name,
repr(self._contourLevels)))
elif len(self._contourLevels) < len(self._contourColors) - 1:
warnings.warn(
"You asked for %i lgridevels but provided %i colors, extra "
"ones will be ignored\nGraphic Method: %s of type %s"
% (len(self._contourLevels), len(self._contourColors),
self._gm.name, self._gm.g_name))
for i, l in enumerate(self._contourLevels):
if i == 0:
C = [self._contourColors[i]]
if numpy.allclose(self._contourLevels[0][0], -1.e20):
# ok it's an extension arrow
L = [self._scalarRange[0] - 1., self._contourLevels[0][1]]
else:
L = list(self._contourLevels[i])
I = [indices[i]]
else:
if l[0] == L[-1] and I[-1] == indices[i]:
# Ok same type lets keep going
if numpy.allclose(l[1], 1.e20):
L.append(self._scalarRange[1] + 1.)
else:
L.append(l[1])
C.append(self._contourColors[i])
else: # ok we need new contouring
tmpLevels.append(L)
tmpColors.append(C)
C = [self._contourColors[i]]
L = self._contourLevels[i]
I = [indices[i]]
tmpLevels.append(L)
tmpColors.append(C)
mappers = []
luts = []
geos = []
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels contnues where one left off
# AND pattern is identical
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
# TODO this should really just be a single polydata that is
# colored by scalars:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b = self._colorMap.index[color]
lut.SetTableValue(0, r / 100., g / 100., b / 100.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], True]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
numLevels = len(self._contourLevels)
if mappers == []: # ok didn't need to have special banded contours
mapper = vtk.vtkPolyDataMapper()
mappers = [mapper]
# Colortable bit
# make sure length match
while len(self._contourColors) < numLevels:
self._contourColors.append(self._contourColors[-1])
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(numLevels)
for i in range(numLevels):
r, g, b = self._colorMap.index[self._contourColors[i]]
lut.SetTableValue(i, r / 100., g / 100., b / 100.)
mapper.SetLookupTable(lut)
if numpy.allclose(self._contourLevels[0], -1.e20):
lmn = self._min - 1.
else:
lmn = self._contourLevels[0]
if numpy.allclose(self._contourLevels[-1], 1.e20):
lmx = self._max + 1.
else:
lmx = self._contourLevels[-1]
mapper.SetScalarRange(lmn, lmx)
self._resultDict["vtk_backend_luts"] = [[lut, [lmn, lmx, True]]]
if self._maskedDataMapper is not None:
# Note that this is different for meshfill -- others prepend.
mappers.append(self._maskedDataMapper)
# This is also different for meshfill, others use
# vcs.utils.getworldcoordinates
x1, x2, y1, y2 = vcs2vtk.getRange(self._gm,
self._vtkDataSetBounds[0],
self._vtkDataSetBounds[1],
self._vtkDataSetBounds[2],
self._vtkDataSetBounds[3])
# Add a second mapper for wireframe meshfill:
if self._gm.mesh:
lineMappers = []
wireLUT = vtk.vtkLookupTable()
wireLUT.SetNumberOfTableValues(1)
wireLUT.SetTableValue(0, 0, 0, 0)
for polyMapper in mappers:
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(
polyMapper.GetInputConnection(0, 0))
lineMapper._useWireFrame = True
# 'noqa' comments disable pep8 checking for these lines. There
# is not a readable way to shorten them due to the unwieldly
# method name.
#
# Setup depth resolution so lines stay above points:
polyMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(0, 1) # noqa
polyMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(1, 1) # noqa
lineMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetLookupTable(wireLUT)
lineMappers.append(lineMapper)
mappers.extend(lineMappers)
# And now we need actors to actually render this thing
actors = []
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
if hasattr(mapper, "_useWireFrame"):
prop = act.GetProperty()
prop.SetRepresentationToWireframe()
if self._vtkGeoTransform is None:
# If using geofilter on wireframed does not get wrppaed not
# sure why so sticking to many mappers
act = vcs2vtk.doWrap(act, [x1, x2, y1, y2],
self._dataWrapModulo)
# TODO See comment in boxfill.
if mapper is self._maskedDataMapper:
actors.append([act, self._maskedDataMapper, [x1, x2, y1, y2]])
else:
actors.append([act, [x1, x2, y1, y2]])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
self._context().fitToViewport(
act, [self._template.data.x1,
self._template.data.x2,
self._template.data.y1,
self._template.data.y2],
wc=[x1, x2, y1, y2], geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=True)
self._resultDict["vtk_backend_actors"] = actors
self._template.plot(self._context().canvas, self._data1, self._gm,
bg=self._context().bg,
X=numpy.arange(self._vtkDataSetBounds[0],
self._vtkDataSetBounds[1] * 1.1,
(self._vtkDataSetBounds[1] -
self._vtkDataSetBounds[0]) / 10.),
Y=numpy.arange(self._vtkDataSetBounds[2],
self._vtkDataSetBounds[3] * 1.1,
(self._vtkDataSetBounds[3] -
self._vtkDataSetBounds[2]) / 10.))
legend = getattr(self._gm, "legend", None)
if self._gm.ext_1:
if isinstance(self._contourLevels[0], list):
if numpy.less(abs(self._contourLevels[0][0]), 1.e20):
# Ok we need to add the ext levels
self._contourLevels.insert(
0, [-1.e20, self._contourLevels[0][0]])
else:
if numpy.less(abs(self._contourLevels[0]), 1.e20):
# need to add an ext
self._contourLevels.insert(0, -1.e20)
if self._gm.ext_2:
if isinstance(self._contourLevels[-1], list):
if numpy.less(abs(self._contourLevels[-1][1]), 1.e20):
# need ext
self._contourLevels.append([self._contourLevels[-1][1],
1.e20])
else:
if numpy.less(abs(self._contourLevels[-1]), 1.e20):
# need exts
self._contourLevels.append(1.e20)
self._resultDict.update(
self._context().renderColorBar(self._template, self._contourLevels,
self._contourColors, legend,
self._colorMap))
if self._context().canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
self._context().plotContinents(x1, x2, y1, y2, projection,
self._dataWrapModulo,
self._template)
grid_dest=dummy.getGrid() s.id="orig" s_regrid2 = s.regrid(grid_dest,regridTool="regrid2") s_regrid2.id="regrid2" s_esmf_lin = s.regrid(grid_dest) s_esmf_lin.id = "ESMF Linear" s_esmf_con = s.regrid(grid_dest,regridTool="esmf",regridMethod="conservative") s_esmf_lin.id = "ESMF Conservative" x=regression.init() t=x.createtemplate() t.blank() t.data.priority=1 t.legend.priority=1 t.dataname.priority=1 t.dataname.y=t.dataname.y*.95 M=EzTemplate.Multi(template=t,x=x,rows=2,columns=2) gm=x.createboxfill() levels= vcs.mkscale(*vcs.minmax(s)) cols = vcs.getcolors(levels) gm.boxfill_type = "custom" gm.fillareacolors = cols gm.levels = levels x.plot(s,M.get(),gm,bg=1) x.plot(s_regrid2,M.get(),gm,bg=1) x.plot(s_esmf_lin,M.get(),gm,bg=1) x.plot(s_esmf_con,M.get(),gm,bg=1) ret = regression.run(x, "esmf_issue_1125.png", png)
def plot(self,
data=None,
mesh=None,
template=None,
meshfill=None,
x=None,
bg=0,
multiple=1.1):
# Create the vcs canvas
if x is None:
x = vcs.init()
## Continents bug
x.setcontinentstype(0)
# gets the thing to plot !
if data is None:
data = self.get()
# Do we use a predefined template ?
if template is None:
template = x.createtemplate()
# Now sets all the things for the template...
# Sets a bunch of template attributes to off
for att in [
'line1',
'line2',
'line3',
'line4',
'box2',
'box3',
'box4',
'min',
'max',
'mean',
'xtic1',
'xtic2',
'ytic1',
'ytic2',
'xvalue',
'yvalue',
'zvalue',
'tvalue',
'xunits',
'yunits',
'zunits',
'tunits',
'source',
'title',
'dataname',
]:
a = getattr(template, att)
setattr(a, 'priority', 0)
for att in [
'xname',
'yname',
]:
a = getattr(template, att)
setattr(a, 'priority', 0)
template.data.x1 = self.PLOT_SETTINGS.x1
template.data.x2 = self.PLOT_SETTINGS.x2
template.data.y1 = self.PLOT_SETTINGS.y1
template.data.y2 = self.PLOT_SETTINGS.y2
template.box1.x1 = self.PLOT_SETTINGS.x1
template.box1.x2 = self.PLOT_SETTINGS.x2
template.box1.y1 = self.PLOT_SETTINGS.y1
template.box1.y2 = self.PLOT_SETTINGS.y2
template.xname.y = self.PLOT_SETTINGS.y2 + .02
template.yname.x = self.PLOT_SETTINGS.x2 + .01
template.xlabel1.y = self.PLOT_SETTINGS.y1
template.xlabel2.y = self.PLOT_SETTINGS.y2
template.xlabel1.texttable = self.PLOT_SETTINGS.tictable
template.xlabel2.texttable = self.PLOT_SETTINGS.tictable
template.xlabel1.textorientation = self.PLOT_SETTINGS.xticorientation
template.xlabel2.textorientation = self.PLOT_SETTINGS.xticorientation
template.ylabel1.x = self.PLOT_SETTINGS.x1
template.ylabel2.x = self.PLOT_SETTINGS.x2
template.ylabel1.texttable = self.PLOT_SETTINGS.tictable
template.ylabel2.texttable = self.PLOT_SETTINGS.tictable
template.ylabel1.textorientation = self.PLOT_SETTINGS.yticorientation
template.ylabel2.textorientation = self.PLOT_SETTINGS.yticorientation
if self.PLOT_SETTINGS.xtic1y1 is not None:
template.xtic1.y1 = self.PLOT_SETTINGS.xtic1y1
template.xtic1.priority = 1
if self.PLOT_SETTINGS.xtic1y2 is not None:
template.xtic1.y2 = self.PLOT_SETTINGS.xtic1y2
template.xtic1.priority = 1
if self.PLOT_SETTINGS.xtic2y1 is not None:
template.xtic2.y1 = self.PLOT_SETTINGS.xtic2y1
template.xtic2.priority = 1
if self.PLOT_SETTINGS.xtic2y2 is not None:
template.xtic2.y2 = self.PLOT_SETTINGS.xtic2y2
template.xtic2.priority = 1
if self.PLOT_SETTINGS.ytic1x1 is not None:
template.ytic1.x1 = self.PLOT_SETTINGS.ytic1x1
template.ytic1.priority = 1
if self.PLOT_SETTINGS.ytic1x2 is not None:
template.ytic1.x2 = self.PLOT_SETTINGS.ytic1x2
template.ytic1.priority = 1
if self.PLOT_SETTINGS.ytic2x1 is not None:
template.ytic2.priority = 1
template.ytic2.x1 = self.PLOT_SETTINGS.ytic2x1
if self.PLOT_SETTINGS.ytic2x2 is not None:
template.ytic2.priority = 1
template.ytic2.x2 = self.PLOT_SETTINGS.ytic2x2
template.legend.x1 = self.PLOT_SETTINGS.legend_x1
template.legend.x2 = self.PLOT_SETTINGS.legend_x2
template.legend.y1 = self.PLOT_SETTINGS.legend_y1
template.legend.y2 = self.PLOT_SETTINGS.legend_y2
try:
tmp = x.createtextorientation('crap22')
except:
tmp = x.gettextorientation('crap22')
tmp.height = 12
#tmp.halign = 'center'
# template.legend.texttable = tmp
template.legend.textorientation = tmp
else:
if isinstance(template, vcs.template.P):
tid = template.name
elif isinstance(template, str):
tid = template
else:
raise 'Error cannot understand what you mean by template=' + str(
template)
template = x.createtemplate()
# Do we use a predefined meshfill ?
if meshfill is None:
mtics = {}
for i in range(100):
mtics[i - .5] = ''
icont = 1
meshfill = x.createmeshfill()
meshfill.xticlabels1 = eval(data.getAxis(1).names)
meshfill.yticlabels1 = eval(data.getAxis(0).names)
meshfill.datawc_x1 = -.5
meshfill.datawc_x2 = data.shape[1] - .5
meshfill.datawc_y1 = -.5
meshfill.datawc_y2 = data.shape[0] - .5
meshfill.mesh = self.PLOT_SETTINGS.draw_mesh
meshfill.missing = self.PLOT_SETTINGS.missing_color
meshfill.xticlabels2 = mtics
meshfill.yticlabels2 = mtics
if self.PLOT_SETTINGS.colormap is None:
self.set_colormap(x)
elif x.getcolormapname() != self.PLOT_SETTINGS.colormap:
x.setcolormap(self.PLOT_SETTINGS.colormap)
if self.PLOT_SETTINGS.levels is None:
min, max = vcs.minmax(data)
if max != 0: max = max + .000001
levs = vcs.mkscale(min, max)
else:
levs = self.PLOT_SETTINGS.levels
if len(levs) > 1:
meshfill.levels = levs
if self.PLOT_SETTINGS.fillareacolors is None:
cols = vcs.getcolors(levs, range(16, 40), split=1)
meshfill.fillareacolors = cols
else:
meshfill.fillareacolors = self.PLOT_SETTINGS.fillareacolors
## self.setmeshfill(x,meshfill,levs)
## if self.PLOT_SETTINGS.legend is None:
## meshfill.legend=vcs.mklabels(levs)
## else:
## meshfill.legend=self.PLOT_SETTINGS.legend
# Now creates the mesh associated
n = int(multiple)
ntot = int((multiple - n) * 10 + .1)
## data=data
sh = list(data.shape)
sh.append(2)
I = MV2.indices((sh[0], sh[1]))
Y = I[0]
X = I[1]
## if ntot>1:
## meshfill.mesh='y'
if ntot == 1:
sh.append(4)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y + .5
M[:, :, 1, 3] = X - .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 4))
elif ntot == 2:
sh.append(3)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5 - (n - 1)
M[:, :, 1, 1] = X - 0.5 + (n - 1)
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
elif ntot == 3:
design = int((multiple - n) * 100 + .1)
if design == 33:
sh.append(3)
M = MV2.zeros(sh)
if n == 1:
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
elif n == 2:
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
elif n == 3:
M[:, :, 0, 0] = Y + .5
M[:, :, 1, 0] = X + .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
elif design == 32:
sh.append(5)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
d = .5 / MV2.sqrt(3.)
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X - .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
if n == 2:
M[:, :, 0, 1] = Y - d
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - .5
M[:, :, 1, 3] = X + .5
M[:, :, 0, 4] = Y - d
M[:, :, 1, 4] = X + .5
elif n == 3:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X + .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
M = MV2.reshape(M, (sh[0] * sh[1], 2, 5))
else:
sh.append(5)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
d = 1. / 3.
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X - .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
if n == 2:
M[:, :, 0, 1] = Y - d
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - .5
M[:, :, 1, 3] = X + .5
M[:, :, 0, 4] = Y - d
M[:, :, 1, 4] = X + .5
elif n == 3:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X + .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
M = MV2.reshape(M, (sh[0] * sh[1], 2, 5))
elif ntot == 4:
sh.append(3)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
elif n == 2:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
elif n == 3:
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
elif n == 4:
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
else:
if isinstance(meshfill, vcs.meshfill.P):
tid = mesh.id
elif isinstance(meshfill, str):
tid = mesh
else:
raise 'Error cannot understand what you mean by meshfill=' + str(
meshfill)
meshfill = x.createmeshfill()
if mesh is None:
x.plot(MV2.ravel(data), M, template, meshfill, bg=bg)
else:
x.plot(MV2.ravel(data), mesh, template, meshfill, bg=bg)
# Now prints the rest of the title, etc...
# but only if n==1
if n == 1:
axes_param = []
for a in data.getAxis(0).id.split('___'):
axes_param.append(a)
for a in data.getAxis(1).id.split('___'):
axes_param.append(a)
nparam = 0
for p in self.parameters_list:
if not p in self.dummies and not p in self.auto_dummies and not p in axes_param:
nparam += 1
if self.verbose: print 'NPARAM:', nparam
if nparam > 0:
for i in range(nparam):
j = MV2.ceil(float(nparam) / (i + 1.))
if j <= i:
break
npc = i # number of lines
npl = int(j) # number of coulmns
if npc * npl < nparam:
npl += 1
# computes space between each line
dl = (.95 - template.data.y2) / npl
dc = .9 / npc
npci = 0 # counter for columns
npli = 0 # counter for lines
for p in self.parameters_list:
if not p in self.dummies and not p in self.auto_dummies and not p in axes_param:
txt = x.createtext(
None, self.PLOT_SETTINGS.parametertable.name, None,
self.PLOT_SETTINGS.parameterorientation.name)
value = getattr(self, p)
if (isinstance(value, (list, tuple))
and len(value) == 1):
txt.string = p + ':' + str(
self.makestring(p, value[0]))
display = 1
elif isinstance(value, (str, int, float, long)):
txt.string = p + ':' + str(
self.makestring(p, value))
display = 1
else:
display = 0
if display:
# Now figures out where to put these...
txt.x = [(npci) * dc + dc / 2. + .05]
txt.y = [1. - (npli) * dl - dl / 2.]
npci += 1
if npci >= npc:
npci = 0
npli += 1
if p in self.altered.keys():
dic = self.altered[p]
if dic['size'] is not None:
txt.size = dic['size']
if dic['color'] is not None:
txt.color = dic['color']
if dic['x'] is not none:
txt.x = dic['x']
if dic['y'] is not none:
txt.y = dic['y']
x.plot(txt, bg=bg, continents=0)
if not self.PLOT_SETTINGS.logo is None:
x.plot(self.PLOT_SETTINGS.logo, bg=bg, continents=0)
if not self.PLOT_SETTINGS.time_stamp is None:
import time
sp = time.ctime().split()
sp = sp[:3] + [sp[-1]]
self.PLOT_SETTINGS.time_stamp.string = ''.join(sp)
x.plot(self.PLOT_SETTINGS.time_stamp, bg=bg, continents=0)
def _plotInternal(self):
prepedContours = self._prepContours()
tmpLevels = prepedContours["tmpLevels"]
tmpIndices = prepedContours["tmpIndices"]
tmpColors = prepedContours["tmpColors"]
tmpOpacities = prepedContours["tmpOpacities"]
style = self._gm.fillareastyle
fareapixelspacing, fareapixelscale = self._patternSpacingAndScale()
mappers = []
luts = []
geos = []
wholeDataMin, wholeDataMax = vcs.minmax(self._data1)
plotting_dataset_bounds = self.getPlottingBounds()
x1, x2, y1, y2 = plotting_dataset_bounds
# We need to do the convertion thing
_convert = self._gm.yaxisconvert
_func = vcs.utils.axisConvertFunctions[_convert]["forward"]
y1 = _func(y1)
y2 = _func(y2)
_convert = self._gm.xaxisconvert
_func = vcs.utils.axisConvertFunctions[_convert]["forward"]
x1 = _func(x1)
x2 = _func(x2)
_colorMap = self.getColorMap()
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels contnues where one left off
# AND pattern is identical
# TODO this should really just be a single polydata that is
# colored by scalars:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
# th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
th.SetInputData(self._vtkDataSetFittedToViewport)
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
# Make the polydata output available here for patterning later
geoFilter2.Update()
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color)
if style == 'solid':
tmpOpacity = tmpOpacities[j]
if tmpOpacity is None:
tmpOpacity = a / 100.
else:
tmpOpacity = tmpOpacities[j] / 100.
lut.SetTableValue(0, r / 100., g / 100., b / 100.,
tmpOpacity)
else:
lut.SetTableValue(0, 1., 1., 1., 0.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], True]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
if self._maskedDataMapper is not None:
# Note that this is different for meshfill -- others prepend.
mappers.append(self._maskedDataMapper)
wireColor = [0, 0, 0, 255]
# Add a second mapper for wireframe meshfill:
if self._gm.mesh:
lineMappers = []
for polyMapper in mappers:
edgeFilter = vtk.vtkExtractEdges()
edgeFilter.SetInputConnection(
polyMapper.GetInputConnection(0, 0))
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(edgeFilter.GetOutputPort(0))
lineMapper._useWireFrame = True
lineMappers.append(lineMapper)
mappers.extend(lineMappers)
# And now we need actors to actually render this thing
actors = []
vp = self._resultDict.get('ratio_autot_viewport', [
self._template.data.x1, self._template.data.x2,
self._template.data.y1, self._template.data.y2
])
cti = 0
ctj = 0
# view and interactive area
view = self._context().contextView
area = vtk.vtkInteractiveArea()
view.GetScene().AddItem(area)
adjusted_plotting_bounds = vcs2vtk.getProjectedBoundsForWorldCoords(
plotting_dataset_bounds, self._gm.projection)
drawAreaBounds = vcs2vtk.computeDrawAreaBounds(
adjusted_plotting_bounds)
[renWinWidth, renWinHeight] = self._context().renWin.GetSize()
geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)),
int(round(vp[2] * renWinHeight)),
int(round((vp[1] - vp[0]) * renWinWidth)),
int(round((vp[3] - vp[2]) * renWinHeight)))
vcs2vtk.configureContextArea(area, drawAreaBounds, geom)
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
mapper.Update()
poly = mapper.GetInput()
item = None
wireframe = False
if hasattr(mapper, "_useWireFrame"):
wireframe = True
if wireframe:
item = vtk.vtkPolyDataItem()
item.SetPolyData(poly)
colorArray = vtk.vtkUnsignedCharArray()
colorArray.SetNumberOfComponents(4)
for i in range(poly.GetNumberOfCells()):
colorArray.InsertNextTypedTuple(wireColor)
item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA)
item.SetMappedColors(colorArray)
area.GetDrawAreaItem().AddItem(item)
elif style == "solid":
if self._needsCellData:
attrs = poly.GetCellData()
else:
attrs = poly.GetPointData()
data = attrs.GetScalars()
deleteColors = False
if data:
lut = mapper.GetLookupTable()
scalarRange = mapper.GetScalarRange()
lut.SetRange(scalarRange)
mappedColors = lut.MapScalars(data,
vtk.VTK_COLOR_MODE_DEFAULT,
0)
deleteColors = True
else:
loc = 'point'
numTuples = poly.GetNumberOfPoints()
if self._needsCellData:
loc = 'cell'
numTuples = poly.GetNumberOfCells()
msg = 'WARNING: meshfill pipeline: poly does not have Scalars '
msg = msg + 'array on {0} data, using solid color'.format(
loc)
print(msg)
color = [0, 0, 0, 255]
mappedColors = vcs2vtk.generateSolidColorArray(
numTuples, color)
mappedColors.SetName('Colors')
item = vtk.vtkPolyDataItem()
item.SetPolyData(poly)
if self._needsCellData:
item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA)
else:
item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA)
item.SetMappedColors(mappedColors)
if deleteColors:
mappedColors.FastDelete()
area.GetDrawAreaItem().AddItem(item)
# TODO See comment in boxfill.
if item is not None:
if mapper is self._maskedDataMapper:
actors.append([
item, self._maskedDataMapper, plotting_dataset_bounds
])
else:
actors.append([item, plotting_dataset_bounds])
if mapper is not self._maskedDataMapper:
if not wireframe:
# Since pattern creation requires a single color, assuming the
# first
if ctj >= len(tmpColors[cti]):
ctj = 0
cti += 1
c = self.getColorIndexOrRGBA(_colorMap,
tmpColors[cti][ctj])
patact = fillareautils.make_patterned_polydata(
poly,
fillareastyle=style,
fillareaindex=tmpIndices[cti],
fillareacolors=c,
fillareaopacity=tmpOpacities[cti],
fillareapixelspacing=fareapixelspacing,
fillareapixelscale=fareapixelscale,
size=self._context().renWin.GetSize(),
screenGeom=self._context().renWin.GetSize())
ctj += 1
if patact is not None:
actors.append([patact, plotting_dataset_bounds])
patMapper = patact.GetMapper()
patMapper.Update()
patPoly = patMapper.GetInput()
patItem = vtk.vtkPolyDataItem()
patItem.SetPolyData(patPoly)
patItem.SetScalarMode(
vtk.VTK_SCALAR_MODE_USE_CELL_DATA)
colorArray = patPoly.GetCellData().GetArray('Colors')
patItem.SetMappedColors(colorArray)
area.GetDrawAreaItem().AddItem(patItem)
actors.append([patItem, plotting_dataset_bounds])
z, t = self.getZandT()
self._resultDict["vtk_backend_actors"] = actors
kwargs = {
"vtk_backend_grid":
self._vtkDataSet,
"dataset_bounds":
self._vtkDataSetBounds,
"plotting_dataset_bounds":
plotting_dataset_bounds,
"vtk_dataset_bounds_no_mask":
self._vtkDataSetBoundsNoMask,
"vtk_backend_geo":
self._vtkGeoTransform,
"vtk_backend_draw_area_bounds":
drawAreaBounds,
"vtk_backend_viewport_scale":
[self._context_xScale, self._context_yScale]
}
if ("ratio_autot_viewport" in self._resultDict):
kwargs["ratio_autot_viewport"] = vp
self._resultDict.update(self._context().renderTemplate(
self._template,
self._data1,
self._gm,
t,
z,
X=numpy.arange(min(x1, x2),
max(x1, x2) * 1.1,
abs(x2 - x1) / 10.),
Y=numpy.arange(min(y1, y2),
max(y1, y2) * 1.1,
abs(y2 - y1) / 10.),
**kwargs))
legend = getattr(self._gm, "legend", None)
if self._gm.ext_1:
if isinstance(self._contourLevels[0], list):
if numpy.less(abs(self._contourLevels[0][0]), 1.e20):
# Ok we need to add the ext levels
self._contourLevels.insert(
0, [-1.e20, self._contourLevels[0][0]])
else:
if numpy.less(abs(self._contourLevels[0]), 1.e20):
# need to add an ext
self._contourLevels.insert(0, -1.e20)
if self._gm.ext_2:
if isinstance(self._contourLevels[-1], list):
if numpy.less(abs(self._contourLevels[-1][1]), 1.e20):
# need ext
self._contourLevels.append(
[self._contourLevels[-1][1], 1.e20])
else:
if numpy.less(abs(self._contourLevels[-1]), 1.e20):
# need exts
self._contourLevels.append(1.e20)
patternArgs = {}
patternArgs['style'] = self._gm.fillareastyle
patternArgs['index'] = self._gm.fillareaindices
if patternArgs['index'] is None:
patternArgs['index'] = [
1,
]
# Compensate for the different viewport size of the colorbar
patternArgs['opacity'] = self._gm.fillareaopacity
patternArgs['pixelspacing'] = [
int(fareapixelspacing[0] / (vp[1] - vp[0])),
int(fareapixelspacing[1] / (vp[3] - vp[2]))
]
patternArgs['pixelscale'] = fareapixelscale / (vp[1] - vp[0])
self._resultDict.update(self._context().renderColorBar(
self._template, self._contourLevels, self._contourColors, legend,
self.getColorMap(), **patternArgs))
projection = vcs.elements["projection"][self._gm.projection]
kwargs['xaxisconvert'] = self._gm.xaxisconvert
kwargs['yaxisconvert'] = self._gm.yaxisconvert
self._context().plotContinents(
self._plot_kargs.get("continents", self._useContinents),
plotting_dataset_bounds, projection, self._dataWrapModulo, vp,
self._template.data.priority, **kwargs)
def plotIsos(self, template=None, bg=0):
if template is None:
template = "thdiags_template"
elif not isinstance(template, type("")):
template = template.name
try:
isotemplate = self.x.createtemplate(template)
except:
isotemplate = self.x.gettemplate(template)
att = dir(isotemplate)
for a in att:
try:
b = getattr(isotemplate, a)
setattr(b, "priority", 0)
except:
pass
isotemplate.data.priority = 1
isotemplate.box1.priority = 1
isotemplate.box1.x1 = isotemplate.data.x1
isotemplate.box1.x2 = isotemplate.data.x2
isotemplate.box1.y1 = isotemplate.data.y1
isotemplate.box1.y2 = isotemplate.data.y2
dX = self.xmax - self.xmin
dY = self.ymax - self.ymin
X = numpy.ma.arange(self.detail, dtype=MV2.float)
X = X * dX / (self.detail - 1) + self.xmin
Xaxis = cdms2.createAxis(X)
X = numpy.ma.resize(X, (self.detail, self.detail))
Y = numpy.ma.arange(self.detail, dtype=MV2.float)
Y = Y * dY / (self.detail - 1) + self.ymin
Yaxis = cdms2.createAxis(Y)
Y = numpy.ma.resize(Y, (self.detail, self.detail))
Y = numpy.ma.transpose(Y)
# Computes T,P on this grid
T, P = self.XY2TP(X, Y)
T = MV2.array(T)
# Potential Temperature
Tp = T / numpy.ma.power(P / 100000.0, self.k)
ws = Ws(T, P)
# Seems like we need not ws after 600mb
ws = numpy.ma.masked_where(numpy.ma.less(P, self.Pmaxmixingratio * 100.0), ws)
T = T - 273.16
Tmin, Tmax = vcs.minmax(T)
Tvalues = self.isotherms.level
if Tvalues == [[0.0, 1.0000000200408773e20]]:
Tvalues = vcs.mkscale(Tmin, Tmax)
# Now sets the isothermsfilled
Tvalues2 = []
for i in range(len(Tvalues) / 2 - 1):
t1, t2 = Tvalues[2 * i], Tvalues[2 * i + 1]
if isinstance(t1, (list, tuple)):
t1, t2 = t1[0], t2[0]
Tvalues2.append([t1, t2])
else:
Tvalues2 = self.isothermsfilled.levels
self.setIso(self.isotherms, Tvalues)
# self.setIso(self.isothermsfilled,Tvalues2)
P = P / 100.0
Pvalues = vcs.mkscale(self.datawc_y2, self.datawc_y1)
self.setIso(self.isobars, Pvalues)
Tp = Tp - 273.16
Tpvalues = self.dryadiabats.level
if Tpvalues == [[0.0, 1.0000000200408773e20]]:
min, max = vcs.minmax(Tp)
Tpvalues = vcs.mkscale(min, max)
self.setIso(self.dryadiabats, Tpvalues)
# Pseudoadiabats
Thevalues = self.pseudoadiabats.level
if Thevalues == [[0.0, 1.0000000200408773e20]]:
Thevalues = vcs.mkevenlevels(-40, 40, 40)
self.setIso(self.pseudoadiabats, Thevalues)
# Mixing Ratio
ws = ws * 1000.0
wsvalues = self.mixingratio.level
if wsvalues == [[0.0, 1.0000000200408773e20]]:
min, max = vcs.minmax(ws)
wsvalues = vcs.mkscale(min, max)
self.setIso(self.mixingratio, wsvalues)
# Figures out where to plot the P labels
dicP = {}
dicPl = vcs.mklabels(Pvalues)
for p in Pvalues:
X, Y = self.TP2XY(self.datawc_x1 + 273.15, p * 100)
if not numpy.ma.isMA(X):
dicP[Y] = dicPl[p]
try:
ttp = self.x.createtexttable("Plabels")
except:
ttp = self.x.gettexttable("Plabels")
ttp.color = self.isobars.linecolors[0]
isotemplate.ylabel1.texttable = ttp
dicT = {}
Tvalues = list(numpy.ma.array(Tvalues).filled().ravel())
dicTl = vcs.mklabels(Tvalues)
for t in Tvalues:
X, Y = self.TP2XY(t + 273.15, self.datawc_y1 * 100)
dicT[X] = dicTl[t]
try:
ttp = self.x.createtexttable("Tlabels")
except:
ttp = self.x.gettexttable("Tlabels")
ttp.color = self.isotherms.linecolors[0]
isotemplate.xlabel1.texttable = ttp
isotemplate.ylabel1.priority = 1
isotemplate.xlabel1.priority = 1
isotemplate.data.x1 = isotemplate.data.x1
isotemplate.data.x2 = isotemplate.data.x2
isotemplate.data.y1 = isotemplate.data.y1
isotemplate.data.y2 = isotemplate.data.y2
self.isotherms.yticlabels1 = dicP
self.isotherms.xticlabels1 = dicT
self.isobars.yticlabels1 = {}
self.isobars.xticlabels1 = {}
self.dryadiabats.yticlabels1 = {}
self.dryadiabats.xticlabels1 = {}
self.pseudoadiabats.yticlabels1 = {}
self.pseudoadiabats.xticlabels1 = {}
self.mixingratio.yticlabels1 = {}
self.mixingratio.xticlabels1 = {}
self.isothermsfilled.datawc_x1 = self.isothermsfilled.datawc_x1
self.isothermsfilled.datawc_x2 = self.isothermsfilled.datawc_x2
self.isothermsfilled.datawc_y1 = self.isothermsfilled.datawc_y1
self.isothermsfilled.datawc_x2 = self.isothermsfilled.datawc_y2
# Puts the dims on it
T.id = "T"
T.setAxis(0, Yaxis)
T.setAxis(1, Xaxis)
P = MV2.array(P)
P.id = "P"
P.setAxis(0, Yaxis)
P.setAxis(1, Xaxis)
Tp = MV2.array(Tp)
Tp.setAxis(0, Yaxis)
Tp.setAxis(1, Xaxis)
ws = MV2.array(ws)
ws.setAxis(0, Yaxis)
ws.setAxis(1, Xaxis)
# plot if self.drawisothermsfilled:
if self.drawisothermsfilled:
self.displays.append(self.x.plot(T, isotemplate, self.isothermsfilled, bg=bg))
if self.drawisotherms:
self.displays.append(self.x.plot(T, isotemplate, self.isotherms, bg=bg))
if self.drawisobars:
self.displays.append(self.x.plot(P, isotemplate, self.isobars, bg=bg))
if self.drawdryadiabats:
self.displays.append(self.x.plot(Tp, isotemplate, self.dryadiabats, bg=bg))
if self.drawpseudoadiabats:
self.plot_pseudo(isotemplate, bg=bg)
if self.drawmixingratio:
self.displays.append(self.x.plot(ws, isotemplate, self.mixingratio, bg=bg))
return
def _plotInternal(self):
tmpLevels = []
tmpColors = []
indices = self._gm.fillareaindices
if indices is None:
indices = [1]
while len(indices) < len(self._contourColors):
indices.append(indices[-1])
if len(self._contourLevels) > len(self._contourColors):
raise RuntimeError(
"You asked for %i levels but provided only %i colors\n"
"Graphic Method: %s of type %s\nLevels: %s"
% (len(self._contourLevels), len(self._contourColors),
self._gm.name, self._gm.g_name,
repr(self._contourLevels)))
elif len(self._contourLevels) < len(self._contourColors) - 1:
warnings.warn(
"You asked for %i lgridevels but provided %i colors, extra "
"ones will be ignored\nGraphic Method: %s of type %s"
% (len(self._contourLevels), len(self._contourColors),
self._gm.name, self._gm.g_name))
for i, l in enumerate(self._contourLevels):
if i == 0:
C = [self._contourColors[i]]
if numpy.allclose(self._contourLevels[0][0], -1.e20):
# ok it's an extension arrow
L = [self._scalarRange[0] - 1., self._contourLevels[0][1]]
else:
L = list(self._contourLevels[i])
I = [indices[i]]
else:
if l[0] == L[-1] and I[-1] == indices[i]:
# Ok same type lets keep going
if numpy.allclose(l[1], 1.e20):
L.append(self._scalarRange[1] + 1.)
else:
L.append(l[1])
C.append(self._contourColors[i])
else: # ok we need new contouring
tmpLevels.append(L)
tmpColors.append(C)
C = [self._contourColors[i]]
L = self._contourLevels[i]
I = [indices[i]]
tmpLevels.append(L)
tmpColors.append(C)
mappers = []
luts = []
cots = []
geos = []
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels contnues where one left off
# AND pattern is identical
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
# TODO this should really just be a single polydata that is
# colored by scalars:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j+1])
th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b = self._colorMap.index[color]
lut.SetTableValue(0, r/100., g/100., b/100.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j+1])
luts.append([lut, [l[j], l[j+1], True]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j+1] < wholeDataMin or l[j] > wholeDataMax):
mappers.append(mapper)
self._resultDict["vtk_backend_luts"] = luts
if len(cots) > 0:
self._resultDict["vtk_backend_contours"] = cots
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
numLevels = len(self._contourLevels)
if mappers == []: # ok didn't need to have special banded contours
mapper = vtk.vtkPolyDataMapper()
mappers = [mapper]
# Colortable bit
# make sure length match
while len(self._contourColors) < numLevels:
self._contourColors.append(self._contourColors[-1])
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(numLevels)
for i in range(numLevels):
r, g, b = self._colorMap.index[self._contourColors[i]]
lut.SetTableValue(i, r / 100., g / 100., b / 100.)
mapper.SetLookupTable(lut)
if numpy.allclose(self._contourLevels[0], -1.e20):
lmn = mn - 1.
else:
lmn = self._contourLevels[0]
if numpy.allclose(self._contourLevels[-1], 1.e20):
lmx = mx + 1.
else:
lmx = self._contourLevels[-1]
mapper.SetScalarRange(lmn, lmx)
self._resultDict["vtk_backend_luts"] = [[lut, [lmn, lmx, True]]]
if self._maskedDataMapper is not None:
# Note that this is different for meshfill -- others prepend.
mappers.append(self._maskedDataMapper)
# This is also different for meshfill, others use
# vcs.utils.getworldcoordinates
x1, x2, y1, y2 = vcs2vtk.getRange(self._gm,
self._vtkDataSetBounds[0],
self._vtkDataSetBounds[1],
self._vtkDataSetBounds[2],
self._vtkDataSetBounds[3])
# Add a second mapper for wireframe meshfill:
if self._gm.mesh:
lineMappers = []
wireLUT = vtk.vtkLookupTable()
wireLUT.SetNumberOfTableValues(1)
wireLUT.SetTableValue(0, 0, 0, 0)
for polyMapper in mappers:
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(
polyMapper.GetInputConnection(0, 0))
lineMapper._useWireFrame = True
# 'noqa' comments disable pep8 checking for these lines. There
# is not a readable way to shorten them due to the unwieldly
# method name.
#
# Setup depth resolution so lines stay above points:
polyMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(0, 1) # noqa
polyMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(1, 1) # noqa
lineMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetLookupTable(wireLUT)
lineMappers.append(lineMapper)
mappers.extend(lineMappers)
# And now we need actors to actually render this thing
actors = []
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
if hasattr(mapper, "_useWireFrame"):
prop = act.GetProperty()
prop.SetRepresentationToWireframe()
if self._vtkGeoTransform is None:
# If using geofilter on wireframed does not get wrppaed not
# sure why so sticking to many mappers
act = vcs2vtk.doWrap(act, [x1, x2, y1, y2],
self._dataWrapModulo)
# TODO See comment in boxfill.
if mapper is self._maskedDataMapper:
actors.append([act, self._maskedDataMapper, [x1, x2, y1, y2]])
else:
actors.append([act, [x1, x2, y1, y2]])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
ren = self._context.fitToViewport(
act, [self._template.data.x1,
self._template.data.x2,
self._template.data.y1,
self._template.data.y2],
wc=[x1, x2, y1, y2], geo=self._vtkGeoTransform,
priority=self._template.data.priority)
self._resultDict["vtk_backend_actors"] = actors
self._template.plot(self._context.canvas, self._data1, self._gm,
bg=self._context.bg,
X=numpy.arange(self._vtkDataSetBounds[0],
self._vtkDataSetBounds[1] * 1.1,
(self._vtkDataSetBounds[1] -
self._vtkDataSetBounds[0]) / 10.),
Y=numpy.arange(self._vtkDataSetBounds[2],
self._vtkDataSetBounds[3] * 1.1,
(self._vtkDataSetBounds[3] -
self._vtkDataSetBounds[2]) / 10.))
legend = getattr(self._gm, "legend", None)
if self._gm.ext_1:
if isinstance(self._contourLevels[0], list):
if numpy.less(abs(self._contourLevels[0][0]), 1.e20):
# Ok we need to add the ext levels
self._contourLevels.insert(0, [-1.e20, levs[0][0]])
else:
if numpy.less(abs(self._contourLevels[0]), 1.e20):
# need to add an ext
self._contourLevels.insert(0, -1.e20)
if self._gm.ext_2:
if isinstance(self._contourLevels[-1], list):
if numpy.less(abs(self._contourLevels[-1][1]), 1.e20):
# need ext
self._contourLevels.append([self._contourLevels[-1][1],
1.e20])
else:
if numpy.less(abs(self._contourLevels[-1]), 1.e20):
# need exts
self._contourLevels.append(1.e20)
self._resultDict.update(
self._context.renderColorBar(self._template, self._contourLevels,
self._contourColors, legend,
self._colorMap))
if self._context.canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
self._context.plotContinents(x1, x2, y1, y2, projection,
self._dataWrapModulo, self._template)
def plotIsos(self, template=None, bg=0):
if template is None:
template = 'thdiags_template'
elif type(template) != type(''):
template = template.name
try:
isotemplate = self.x.createtemplate(template)
except:
isotemplate = self.x.gettemplate(template)
att = dir(isotemplate)
for a in att:
try:
b = getattr(isotemplate, a)
setattr(b, 'priority', 0)
except:
pass
isotemplate.data.priority = 1
isotemplate.box1.priority = 1
isotemplate.box1.x1 = isotemplate.data.x1
isotemplate.box1.x2 = isotemplate.data.x2
isotemplate.box1.y1 = isotemplate.data.y1
isotemplate.box1.y2 = isotemplate.data.y2
dX = self.xmax - self.xmin
dY = self.ymax - self.ymin
X = numpy.ma.arange(self.detail, dtype=MV2.float)
X = X * dX / (self.detail - 1) + self.xmin
Xaxis = cdms2.createAxis(X)
X = numpy.ma.resize(X, (self.detail, self.detail))
Y = numpy.ma.arange(self.detail, dtype=MV2.float)
Y = Y * dY / (self.detail - 1) + self.ymin
Yaxis = cdms2.createAxis(Y)
Y = numpy.ma.resize(Y, (self.detail, self.detail))
Y = numpy.ma.transpose(Y)
# Computes T,P on this grid
T, P = self.XY2TP(X, Y)
T = MV2.array(T)
# Potential Temperature
Tp = T / numpy.ma.power(P / 100000., self.k)
ws = Ws(T, P)
# Seems like we need not ws after 600mb
ws = numpy.ma.masked_where(
numpy.ma.less(P, self.Pmaxmixingratio * 100.), ws)
T = T - 273.16
Tmin, Tmax = vcs.minmax(T)
Tvalues = self.isotherms.level
if Tvalues == [[0.0, 1.0000000200408773e+20]]:
Tvalues = vcs.mkscale(Tmin, Tmax)
## Now sets the isothermsfilled
Tvalues2 = []
for i in range(len(Tvalues) / 2 - 1):
t1, t2 = Tvalues[2 * i], Tvalues[2 * i + 1]
if isinstance(t1, (list, tuple)):
t1, t2 = t1[0], t2[0]
Tvalues2.append([t1, t2])
else:
Tvalues2 = self.isothermsfilled.levels
self.setIso(self.isotherms, Tvalues)
## self.setIso(self.isothermsfilled,Tvalues2)
P = P / 100.
Pvalues = vcs.mkscale(self.datawc_y2, self.datawc_y1)
self.setIso(self.isobars, Pvalues)
Tp = Tp - 273.16
Tpvalues = self.dryadiabats.level
if Tpvalues == [[0.0, 1.0000000200408773e+20]]:
min, max = vcs.minmax(Tp)
Tpvalues = vcs.mkscale(min, max)
self.setIso(self.dryadiabats, Tpvalues)
## Pseudoadiabats
Thevalues = self.pseudoadiabats.level
if Thevalues == [[0.0, 1.0000000200408773e+20]]:
Thevalues = vcs.mkevenlevels(-40, 40, 40)
self.setIso(self.pseudoadiabats, Thevalues)
## Mixing Ratio
ws = ws * 1000.
wsvalues = self.mixingratio.level
if wsvalues == [[0.0, 1.0000000200408773e+20]]:
min, max = vcs.minmax(ws)
wsvalues = vcs.mkscale(min, max)
self.setIso(self.mixingratio, wsvalues)
# Figures out where to plot the P labels
dicP = {}
dicPl = vcs.mklabels(Pvalues)
for p in Pvalues:
X, Y = self.TP2XY(self.datawc_x1 + 273.15, p * 100)
if not numpy.ma.isMA(X):
dicP[Y] = dicPl[p]
try:
ttp = self.x.createtexttable('Plabels')
except:
ttp = self.x.gettexttable('Plabels')
ttp.color = self.isobars.linecolors[0]
isotemplate.ylabel1.texttable = ttp
dicT = {}
Tvalues = list(numpy.ma.array(Tvalues).filled().ravel())
dicTl = vcs.mklabels(Tvalues)
for t in Tvalues:
X, Y = self.TP2XY(t + 273.15, self.datawc_y1 * 100)
dicT[X] = dicTl[t]
try:
ttp = self.x.createtexttable('Tlabels')
except:
ttp = self.x.gettexttable('Tlabels')
ttp.color = self.isotherms.linecolors[0]
isotemplate.xlabel1.texttable = ttp
isotemplate.ylabel1.priority = 1
isotemplate.xlabel1.priority = 1
isotemplate.data.x1 = isotemplate.data.x1
isotemplate.data.x2 = isotemplate.data.x2
isotemplate.data.y1 = isotemplate.data.y1
isotemplate.data.y2 = isotemplate.data.y2
self.isotherms.yticlabels1 = dicP
self.isotherms.xticlabels1 = dicT
self.isobars.yticlabels1 = {}
self.isobars.xticlabels1 = {}
self.dryadiabats.yticlabels1 = {}
self.dryadiabats.xticlabels1 = {}
self.pseudoadiabats.yticlabels1 = {}
self.pseudoadiabats.xticlabels1 = {}
self.mixingratio.yticlabels1 = {}
self.mixingratio.xticlabels1 = {}
self.isothermsfilled.datawc_x1 = self.isothermsfilled.datawc_x1
self.isothermsfilled.datawc_x2 = self.isothermsfilled.datawc_x2
self.isothermsfilled.datawc_y1 = self.isothermsfilled.datawc_y1
self.isothermsfilled.datawc_x2 = self.isothermsfilled.datawc_y2
# Puts the dims on it
T.id = 'T'
T.setAxis(0, Yaxis)
T.setAxis(1, Xaxis)
P = MV2.array(P)
P.id = 'P'
P.setAxis(0, Yaxis)
P.setAxis(1, Xaxis)
Tp = MV2.array(Tp)
Tp.setAxis(0, Yaxis)
Tp.setAxis(1, Xaxis)
ws = MV2.array(ws)
ws.setAxis(0, Yaxis)
ws.setAxis(1, Xaxis)
# plot if self.drawisothermsfilled:
if self.drawisothermsfilled:
self.displays.append(
self.x.plot(T, isotemplate, self.isothermsfilled, bg=bg))
if self.drawisotherms:
self.displays.append(
self.x.plot(T, isotemplate, self.isotherms, bg=bg))
if self.drawisobars:
self.displays.append(
self.x.plot(P, isotemplate, self.isobars, bg=bg))
if self.drawdryadiabats:
self.displays.append(
self.x.plot(Tp, isotemplate, self.dryadiabats, bg=bg))
if self.drawpseudoadiabats:
self.plot_pseudo(isotemplate, bg=bg)
if self.drawmixingratio:
self.displays.append(
self.x.plot(ws, isotemplate, self.mixingratio, bg=bg))
return
# Adapted for numpy/ma/cdms2 by convertcdms.py
import sys,cdms2 as cdms,vcs,cdtime,support,os
t0=cdtime.comptime(1987,8)
t1=cdtime.comptime(1988,12)
f=cdms.open(os.path.join(cdms.__path__[0],'..','..','..','..','sample_data','ta_ncep_87-6-88-4.nc'))
s=f('ta',latitude=slice(5,6),level=slice(0,1),squeeze=1)
mn,mx=vcs.minmax(s)
s=s/mx
s2=s()
## s.info()
## print s.shape
t2=s2.getTime()
t2.units='months since 1949-5'
x=vcs.init()
y=vcs.init()
b=x.createoutline('new2')
b.datawc_y1=t0
b.datawc_y2=t1
#b.list()
x.plot(s,b,bg=support.bg)
support.check_plot(x)
y.plot(s2,b,bg=support.bg)
support.check_plot(y)
x.clear()
y.clear()
def _actualCreate( self, parent=None, min=None, max=None, save_file=None, rate=5., bitrate=None, ffmpegoptions='', axis=0, sender=None):
alen = None
dims = self.vcs_self.canvasinfo()
if dims['height']<500:
factor = 2
else:
factor=1
if dims["width"]<dims["height"]:
self.canvas.portrait(width=dims["width"],height=dims["height"])
self.canvas.setbgoutputdimensions(width = dims['width']*factor,height=dims['height']*factor,units='pixel')
truncated = False
vcs_ai = list(self.vcs_self.animate_info)
self.vcs_self.clear()
for I in vcs_ai:
if alen is None:
alen = I[1][0].shape[axis]
else:
l = I[1][0].shape[axis]
if l!=alen:
alen = numpy.minimum(alen,l)
truncated = True
if truncated:
warnings.warn("Because of inconsistent shapes over axis: %i, the animation length will be truncated to: %i\n" % (axis,alen))
if self.animation_seed is not None:
if self.animation_files != []:
for fnm in self.animation_files:
os.remove(fnm)
self.animation_seed = None
self.animation_files = []
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Note: cannot set the min and max values if the default graphics method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
if ( do_min_max == 'yes' ):
minv = []
maxv=[]
if (min is None) or (max is None):
for i in range(len(self.vcs_self.animate_info)):
minv.append( 1.0e77 )
maxv.append( -1.0e77 )
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
mins, maxs = vcs.minmax(slab)
minv[i] = float(numpy.minimum(float(minv[i]), float(mins)))
maxv[i] = float(numpy.maximum(float(maxv[i]), float(maxs)))
elif isinstance(min,list) or isinstance(max,list):
for i in range(len(self.vcs_self.animate_info)):
try:
minv.append( min[i] )
except:
minv.append( min[-1] )
try:
maxv.append( max[i] )
except:
maxv.append( max[-1] )
else:
for i in range(len(self.vcs_self.animate_info)):
minv.append( min )
maxv.append( max )
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the data set will be used.
for i in range(len(self.vcs_self.animate_info)):
try:
self.set_animation_min_max( minv[i], maxv[i], i )
except Exception,err:
pass # if it is default, then you cannot set the min and max, so pass.
def plot(self, data=None, mesh=None, template=None,
meshfill=None, x=None, bg=0, multiple=1.1):
self.bg = bg
# Create the vcs canvas
if x is not None:
self.x = x
# Continents bug
# x.setcontinentstype(0)
# gets the thing to plot !
if data is None:
data = self.get()
# Do we use a predefined template ?
if template is None:
template = self.generateTemplate()
else:
if isinstance(template, vcs.template.P):
tid = template.name
elif isinstance(template, str):
tid = template
else:
raise 'Error cannot understand what you mean by template=' + \
str(template)
template = vcs.createtemplate(source=tid)
# Do we use a predefined meshfill ?
if meshfill is None:
mtics = {}
for i in range(100):
mtics[i - .5] = ''
meshfill = vcs.createmeshfill()
meshfill.xticlabels1 = eval(data.getAxis(1).names)
meshfill.yticlabels1 = eval(data.getAxis(0).names)
meshfill.datawc_x1 = -.5
meshfill.datawc_x2 = data.shape[1] - .5
meshfill.datawc_y1 = -.5
meshfill.datawc_y2 = data.shape[0] - .5
meshfill.mesh = self.PLOT_SETTINGS.draw_mesh
meshfill.missing = self.PLOT_SETTINGS.missing_color
meshfill.xticlabels2 = mtics
meshfill.yticlabels2 = mtics
if self.PLOT_SETTINGS.colormap is None:
self.set_colormap()
elif self.x.getcolormapname() != self.PLOT_SETTINGS.colormap:
self.x.setcolormap(self.PLOT_SETTINGS.colormap)
if self.PLOT_SETTINGS.levels is None:
min, max = vcs.minmax(data)
if max != 0:
max = max + .000001
levs = vcs.mkscale(min, max)
else:
levs = self.PLOT_SETTINGS.levels
if len(levs) > 1:
meshfill.levels = levs
if self.PLOT_SETTINGS.fillareacolors is None:
if self.PLOT_SETTINGS.colormap is None:
# Default colormap only use range 16->40
cols = vcs.getcolors(levs, list(range(16, 40)), split=1)
else:
cols = vcs.getcolors(levs, split=1)
meshfill.fillareacolors = cols
else:
meshfill.fillareacolors = self.PLOT_SETTINGS.fillareacolors
# Now creates the mesh associated
n = int(multiple)
ntot = int((multiple - n) * 10 + .1)
sh = list(data.shape)
sh.append(2)
Indx = MV2.indices((sh[0], sh[1]))
Y = Indx[0]
X = Indx[1]
if ntot == 1:
sh.append(4)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y + .5
M[:, :, 1, 3] = X - .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 4))
elif ntot == 2:
sh.append(3)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5 - (n - 1)
M[:, :, 1, 1] = X - 0.5 + (n - 1)
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
elif ntot == 3:
design = int((multiple - n) * 100 + .1)
if design == 33:
sh.append(3)
M = MV2.zeros(sh)
if n == 1:
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
elif n == 2:
M[:, :, 0, 0] = Y - .5
M[:, :, 1, 0] = X - .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
elif n == 3:
M[:, :, 0, 0] = Y + .5
M[:, :, 1, 0] = X + .5
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
elif design == 32:
sh.append(5)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
d = .5 / MV2.sqrt(3.)
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X - .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
if n == 2:
M[:, :, 0, 1] = Y - d
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - .5
M[:, :, 1, 3] = X + .5
M[:, :, 0, 4] = Y - d
M[:, :, 1, 4] = X + .5
elif n == 3:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X + .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
M = MV2.reshape(M, (sh[0] * sh[1], 2, 5))
else:
sh.append(5)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
d = 1. / 3.
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X - .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
if n == 2:
M[:, :, 0, 1] = Y - d
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
M[:, :, 0, 3] = Y - .5
M[:, :, 1, 3] = X + .5
M[:, :, 0, 4] = Y - d
M[:, :, 1, 4] = X + .5
elif n == 3:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M[:, :, 0, 3] = Y - d
M[:, :, 1, 3] = X + .5
# dummy point for n==1 or 3
M[:, :, 0, 4] = Y
M[:, :, 1, 4] = X
M = MV2.reshape(M, (sh[0] * sh[1], 2, 5))
elif ntot == 4:
sh.append(3)
M = MV2.zeros(sh)
M[:, :, 0, 0] = Y
M[:, :, 1, 0] = X
if n == 1:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X - .5
elif n == 2:
M[:, :, 0, 1] = Y + .5
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X - .5
elif n == 3:
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X - .5
M[:, :, 0, 2] = Y - .5
M[:, :, 1, 2] = X + .5
elif n == 4:
M[:, :, 0, 1] = Y - .5
M[:, :, 1, 1] = X + .5
M[:, :, 0, 2] = Y + .5
M[:, :, 1, 2] = X + .5
M = MV2.reshape(M, (sh[0] * sh[1], 2, 3))
else:
if isinstance(meshfill, vcs.meshfill.P):
tid = mesh.id
elif isinstance(meshfill, str):
tid = mesh
else:
raise 'Error cannot understand what you mean by meshfill=' + \
str(meshfill)
meshfill = vcs.createmeshfill(source=tid)
if mesh is None:
mesh = M
raveled = MV2.ravel(data)
self.x.plot(raveled, mesh, template, meshfill, bg=self.bg)
# If required plot values
if self.PLOT_SETTINGS.values.show:
self.draw_values(raveled, mesh, meshfill, template)
# Now prints the rest of the title, etc...
# but only if n==1
if n == 1:
axes_param = []
for a in data.getAxis(0).id.split('___'):
axes_param.append(a)
for a in data.getAxis(1).id.split('___'):
axes_param.append(a)
nparam = 0
for p in self.parameters_list:
if p not in self.dummies and \
p not in self.auto_dummies and \
p not in axes_param:
nparam += 1
if self.verbose:
print('NPARAM:', nparam)
if nparam > 0:
for i in range(nparam):
j = MV2.ceil(float(nparam) / (i + 1.))
if j <= i:
break
npc = i # number of lines
npl = int(j) # number of coulmns
if npc * npl < nparam:
npl += 1
# computes space between each line
dl = (.95 - template.data.y2) / npl
dc = .9 / npc
npci = 0 # counter for columns
npli = 0 # counter for lines
for p in self.parameters_list:
if p not in self.dummies and \
p not in self.auto_dummies and \
p not in axes_param:
txt = self.x.createtext(
None,
self.PLOT_SETTINGS.parametertable.name,
None,
self.PLOT_SETTINGS.parameterorientation.name)
value = getattr(self, p)
if (isinstance(value, (list, tuple)) and
len(value) == 1):
txt.string = p + ':' + \
str(self.makestring(p, value[0]))
display = 1
elif isinstance(value, (str, int, float)):
txt.string = p + ':' + \
str(self.makestring(p, value))
display = 1
else:
display = 0
if display:
# Now figures out where to put these...
txt.x = [(npci) * dc + dc / 2. + .05]
txt.y = [1. - (npli) * dl - dl / 2.]
npci += 1
if npci >= npc:
npci = 0
npli += 1
if p in list(self.altered.keys()):
dic = self.altered[p]
if dic['size'] is not None:
txt.size = dic['size']
if dic['color'] is not None:
txt.color = dic['color']
if dic['x'] is not None:
txt.x = dic['x']
if dic['y'] is not None:
txt.y = dic['y']
self.x.plot(txt, bg=self.bg, continents=0)
if self.PLOT_SETTINGS.time_stamp is not None:
sp = time.ctime().split()
sp = sp[:3] + [sp[-1]]
self.PLOT_SETTINGS.time_stamp.string = ''.join(sp)
self.x.plot(
self.PLOT_SETTINGS.time_stamp,
bg=self.bg,
continents=0)
if self.PLOT_SETTINGS.logo is not None:
self.PLOT_SETTINGS.logo.plot(self.x, bg=self.bg)
return mesh, template, meshfill
canvas.bgY = 750
levs = levels(var, partition_count=10)
stat_iso = vcs.createisofill()
int_levs = []
for l in levs:
int_levs.append(int(l))
stat_iso.levels = int_levs
stat_iso.ext_2 = True
stat_iso.ext_1 = True
stat_iso.missing = 1
stat_iso.fillareacolors = vcs.getcolors(stat_iso.levels, split=0)
iso = vcs.createisofill()
v_min, v_max = vcs.minmax(var[0])
scale = vcs.mkscale(v_min, v_max)
iso.levels = scale
iso.ext_2 = True
iso.ext_1 = True
iso.missing = 1
iso.fillareacolors = vcs.getcolors(iso.levels, split=0)
flat = var.flatten().data
stats_variance, stats_binned = calculate_variance(levs, flat)
auto_variance, auto_binned = calculate_variance(scale, flat)
stats_counts = []
auto_counts = []
for index in range(len(levs)):
stat_var = stats_variance[index]
auto_var = auto_variance[index]
def plot(self,data=None,mesh=None,template=None,meshfill=None,x=None,bg=0,multiple=1.1):
# Create the vcs canvas
if x is None:
x=vcs.init()
## Continents bug
x.setcontinentstype(0)
# gets the thing to plot !
if data is None:
data=self.get()
# Do we use a predefined template ?
if template is None:
template=x.createtemplate()
# Now sets all the things for the template...
# Sets a bunch of template attributes to off
for att in [
'line1','line2','line3','line4',
'box2','box3','box4',
'min','max','mean',
'xtic1','xtic2',
'ytic1','ytic2',
'xvalue','yvalue','zvalue','tvalue',
'xunits','yunits','zunits','tunits',
'source','title','dataname',
]:
a=getattr(template,att)
setattr(a,'priority',0)
for att in [
'xname','yname',
]:
a=getattr(template,att)
setattr(a,'priority',0)
template.data.x1=self.PLOT_SETTINGS.x1
template.data.x2=self.PLOT_SETTINGS.x2
template.data.y1=self.PLOT_SETTINGS.y1
template.data.y2=self.PLOT_SETTINGS.y2
template.box1.x1=self.PLOT_SETTINGS.x1
template.box1.x2=self.PLOT_SETTINGS.x2
template.box1.y1=self.PLOT_SETTINGS.y1
template.box1.y2=self.PLOT_SETTINGS.y2
template.xname.y=self.PLOT_SETTINGS.y2+.02
template.yname.x=self.PLOT_SETTINGS.x2+.01
template.xlabel1.y=self.PLOT_SETTINGS.y1
template.xlabel2.y=self.PLOT_SETTINGS.y2
template.xlabel1.texttable=self.PLOT_SETTINGS.tictable
template.xlabel2.texttable=self.PLOT_SETTINGS.tictable
template.xlabel1.textorientation=self.PLOT_SETTINGS.xticorientation
template.xlabel2.textorientation=self.PLOT_SETTINGS.xticorientation
template.ylabel1.x=self.PLOT_SETTINGS.x1
template.ylabel2.x=self.PLOT_SETTINGS.x2
template.ylabel1.texttable=self.PLOT_SETTINGS.tictable
template.ylabel2.texttable=self.PLOT_SETTINGS.tictable
template.ylabel1.textorientation=self.PLOT_SETTINGS.yticorientation
template.ylabel2.textorientation=self.PLOT_SETTINGS.yticorientation
if self.PLOT_SETTINGS.xtic1y1 is not None:
template.xtic1.y1=self.PLOT_SETTINGS.xtic1y1
template.xtic1.priority=1
if self.PLOT_SETTINGS.xtic1y2 is not None:
template.xtic1.y2=self.PLOT_SETTINGS.xtic1y2
template.xtic1.priority=1
if self.PLOT_SETTINGS.xtic2y1 is not None:
template.xtic2.y1=self.PLOT_SETTINGS.xtic2y1
template.xtic2.priority=1
if self.PLOT_SETTINGS.xtic2y2 is not None:
template.xtic2.y2=self.PLOT_SETTINGS.xtic2y2
template.xtic2.priority=1
if self.PLOT_SETTINGS.ytic1x1 is not None:
template.ytic1.x1=self.PLOT_SETTINGS.ytic1x1
template.ytic1.priority=1
if self.PLOT_SETTINGS.ytic1x2 is not None:
template.ytic1.x2=self.PLOT_SETTINGS.ytic1x2
template.ytic1.priority=1
if self.PLOT_SETTINGS.ytic2x1 is not None:
template.ytic2.priority=1
template.ytic2.x1=self.PLOT_SETTINGS.ytic2x1
if self.PLOT_SETTINGS.ytic2x2 is not None:
template.ytic2.priority=1
template.ytic2.x2=self.PLOT_SETTINGS.ytic2x2
template.legend.x1=self.PLOT_SETTINGS.legend_x1
template.legend.x2=self.PLOT_SETTINGS.legend_x2
template.legend.y1=self.PLOT_SETTINGS.legend_y1
template.legend.y2=self.PLOT_SETTINGS.legend_y2
try:
tmp = x.createtextorientation('crap22')
except:
tmp = x.gettextorientation('crap22')
tmp.height = 12
#tmp.halign = 'center'
# template.legend.texttable = tmp
template.legend.textorientation = tmp
else:
if isinstance(template,vcs.template.P):
tid=template.name
elif isinstance(template,str):
tid=template
else:
raise 'Error cannot understand what you mean by template='+str(template)
template=x.createtemplate()
# Do we use a predefined meshfill ?
if meshfill is None:
mtics={}
for i in range(100):
mtics[i-.5]=''
icont = 1
meshfill=x.createmeshfill()
meshfill.xticlabels1=eval(data.getAxis(1).names)
meshfill.yticlabels1=eval(data.getAxis(0).names)
meshfill.datawc_x1=-.5
meshfill.datawc_x2=data.shape[1]-.5
meshfill.datawc_y1=-.5
meshfill.datawc_y2=data.shape[0]-.5
meshfill.mesh=self.PLOT_SETTINGS.draw_mesh
meshfill.missing=self.PLOT_SETTINGS.missing_color
meshfill.xticlabels2=mtics
meshfill.yticlabels2=mtics
if self.PLOT_SETTINGS.colormap is None:
self.set_colormap(x)
elif x.getcolormapname()!=self.PLOT_SETTINGS.colormap:
x.setcolormap(self.PLOT_SETTINGS.colormap)
if self.PLOT_SETTINGS.levels is None:
min,max=vcs.minmax(data)
if max!=0: max=max+.000001
levs=vcs.mkscale(min,max)
else:
levs=self.PLOT_SETTINGS.levels
if len(levs)>1:
meshfill.levels=levs
if self.PLOT_SETTINGS.fillareacolors is None:
cols=vcs.getcolors(levs,range(16,40),split=1)
meshfill.fillareacolors=cols
else:
meshfill.fillareacolors=self.PLOT_SETTINGS.fillareacolors
## self.setmeshfill(x,meshfill,levs)
## if self.PLOT_SETTINGS.legend is None:
## meshfill.legend=vcs.mklabels(levs)
## else:
## meshfill.legend=self.PLOT_SETTINGS.legend
# Now creates the mesh associated
n=int(multiple)
ntot=int((multiple-n)*10+.1)
## data=data
sh=list(data.shape)
sh.append(2)
I=MV2.indices((sh[0],sh[1]))
Y=I[0]
X=I[1]
## if ntot>1:
## meshfill.mesh='y'
if ntot == 1:
sh.append(4)
M=MV2.zeros(sh)
M[:,:,0,0]=Y-.5
M[:,:,1,0]=X-.5
M[:,:,0,1]=Y-.5
M[:,:,1,1]=X+.5
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X+.5
M[:,:,0,3]=Y+.5
M[:,:,1,3]=X-.5
M=MV2.reshape(M,(sh[0]*sh[1],2,4))
elif ntot==2:
sh.append(3)
M=MV2.zeros(sh)
M[:,:,0,0]=Y-.5
M[:,:,1,0]=X-.5
M[:,:,0,1]=Y+.5-(n-1)
M[:,:,1,1]=X-0.5+(n-1)
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X+.5
M=MV2.reshape(M,(sh[0]*sh[1],2,3))
elif ntot==3:
design=int((multiple-n)*100+.1)
if design==33:
sh.append(3)
M=MV2.zeros(sh)
if n==1:
M[:,:,0,0]=Y-.5
M[:,:,1,0]=X-.5
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X-.5
elif n==2:
M[:,:,0,0]=Y-.5
M[:,:,1,0]=X-.5
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X+.5
elif n==3:
M[:,:,0,0]=Y+.5
M[:,:,1,0]=X+.5
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X+.5
M=MV2.reshape(M,(sh[0]*sh[1],2,3))
elif design==32:
sh.append(5)
M=MV2.zeros(sh)
M[:,:,0,0]=Y
M[:,:,1,0]=X
d=.5/MV2.sqrt(3.)
if n==1:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X-.5
M[:,:,0,3]=Y-d
M[:,:,1,3]=X-.5
# dummy point for n==1 or 3
M[:,:,0,4]=Y
M[:,:,1,4]=X
if n==2:
M[:,:,0,1]=Y-d
M[:,:,1,1]=X-.5
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X-.5
M[:,:,0,3]=Y-.5
M[:,:,1,3]=X+.5
M[:,:,0,4]=Y-d
M[:,:,1,4]=X+.5
elif n==3:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X+.5
M[:,:,0,3]=Y-d
M[:,:,1,3]=X+.5
# dummy point for n==1 or 3
M[:,:,0,4]=Y
M[:,:,1,4]=X
M=MV2.reshape(M,(sh[0]*sh[1],2,5))
else:
sh.append(5)
M=MV2.zeros(sh)
M[:,:,0,0]=Y
M[:,:,1,0]=X
d=1./3.
if n==1:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X-.5
M[:,:,0,3]=Y-d
M[:,:,1,3]=X-.5
# dummy point for n==1 or 3
M[:,:,0,4]=Y
M[:,:,1,4]=X
if n==2:
M[:,:,0,1]=Y-d
M[:,:,1,1]=X-.5
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X-.5
M[:,:,0,3]=Y-.5
M[:,:,1,3]=X+.5
M[:,:,0,4]=Y-d
M[:,:,1,4]=X+.5
elif n==3:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X+.5
M[:,:,0,3]=Y-d
M[:,:,1,3]=X+.5
# dummy point for n==1 or 3
M[:,:,0,4]=Y
M[:,:,1,4]=X
M=MV2.reshape(M,(sh[0]*sh[1],2,5))
elif ntot==4:
sh.append(3)
M=MV2.zeros(sh)
M[:,:,0,0]=Y
M[:,:,1,0]=X
if n==1:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X+.5
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X-.5
elif n==2:
M[:,:,0,1]=Y+.5
M[:,:,1,1]=X-.5
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X-.5
elif n==3:
M[:,:,0,1]=Y-.5
M[:,:,1,1]=X-.5
M[:,:,0,2]=Y-.5
M[:,:,1,2]=X+.5
elif n==4:
M[:,:,0,1]=Y-.5
M[:,:,1,1]=X+.5
M[:,:,0,2]=Y+.5
M[:,:,1,2]=X+.5
M=MV2.reshape(M,(sh[0]*sh[1],2,3))
else:
if isinstance(meshfill,vcs.meshfill.P):
tid=mesh.id
elif isinstance(meshfill,str):
tid=mesh
else:
raise 'Error cannot understand what you mean by meshfill='+str(meshfill)
meshfill=x.createmeshfill()
if mesh is None:
x.plot(MV2.ravel(data),M,template,meshfill,bg=bg)
else:
x.plot(MV2.ravel(data),mesh,template,meshfill,bg=bg)
# Now prints the rest of the title, etc...
# but only if n==1
if n==1:
axes_param=[]
for a in data.getAxis(0).id.split('___'):
axes_param.append(a)
for a in data.getAxis(1).id.split('___'):
axes_param.append(a)
nparam=0
for p in self.parameters_list:
if not p in self.dummies and not p in self.auto_dummies and not p in axes_param:
nparam+=1
if self.verbose: print 'NPARAM:',nparam
if nparam>0:
for i in range(nparam):
j=MV2.ceil(float(nparam)/(i+1.))
if j<=i:
break
npc=i # number of lines
npl=int(j) # number of coulmns
if npc*npl<nparam :
npl+=1
# computes space between each line
dl=(.95-template.data.y2)/npl
dc=.9/npc
npci=0 # counter for columns
npli=0 # counter for lines
for p in self.parameters_list:
if not p in self.dummies and not p in self.auto_dummies and not p in axes_param:
txt=x.createtext(None,self.PLOT_SETTINGS.parametertable.name,None,self.PLOT_SETTINGS.parameterorientation.name)
value=getattr(self,p)
if (isinstance(value,(list,tuple)) and len(value)==1):
txt.string=p+':'+str(self.makestring(p,value[0]))
display=1
elif isinstance(value,(str,int,float,long)):
txt.string=p+':'+str(self.makestring(p,value))
display=1
else:
display=0
if display:
# Now figures out where to put these...
txt.x=[(npci)*dc+dc/2.+.05]
txt.y=[1.-(npli)*dl-dl/2.]
npci+=1
if npci>=npc:
npci=0
npli+=1
if p in self.altered.keys():
dic=self.altered[p]
if dic['size'] is not None:
txt.size=dic['size']
if dic['color'] is not None:
txt.color=dic['color']
if dic['x'] is not none:
txt.x=dic['x']
if dic['y'] is not none:
txt.y=dic['y']
x.plot(txt,bg=bg,continents=0)
if not self.PLOT_SETTINGS.logo is None:
x.plot(self.PLOT_SETTINGS.logo,bg=bg,continents=0)
if not self.PLOT_SETTINGS.time_stamp is None:
import time
sp=time.ctime().split()
sp=sp[:3]+[sp[-1]]
self.PLOT_SETTINGS.time_stamp.string=''.join(sp)
x.plot(self.PLOT_SETTINGS.time_stamp,bg=bg,continents=0)
def create(self,
parent=None,
min=None,
max=None,
save_file=None,
thread_it=1,
rate=None,
bitrate=None,
ffmpegoptions=''):
from vcs import minmax
from numpy.ma import maximum, minimum
# Cannot "Run" or "Create" an animation while already creating an
# animation
if self.run_flg == 1:
return
if self.vcs_self.canvas.creating_animation() == 1:
return
if self.vcs_self.animate_info == []:
str = "No data found!"
showerror("Error Message to User", str)
return
# Stop the (thread) execution of the X main loop (if it is running).
self.vcs_self.canvas.stopxmainloop()
# Force VCS to update its orientation, needed when the user changes the
# VCS Canvas size.
self.vcs_self.canvas.updateorientation()
# Make sure the animate information is up-to-date for creating images
if ((self.gui_popup == 1) and (self.create_flg == 0)):
self.update_animate_display_list()
# Save the min and max values for the graphics methods.
# Will need to restore values back when animation is done.
self.save_original_min_max()
# Set up the animation min and max values by changing the graphics method
# Note: cannot set the min and max values if the default graphics
# method is set.
do_min_max = 'yes'
try:
if (parent is not None) and (parent.iso_spacing == 'Log'):
do_min_max = 'no'
except:
pass
# Draw specified continental outlines if needed.
self.continents_hold_value = self.vcs_self.canvas.getcontinentstype()
self.vcs_self.canvas.setcontinentstype(self.continents_value)
if (do_min_max == 'yes'):
minv = []
maxv = []
if (min is None) or (max is None):
for i in range(len(self.vcs_self.animate_info)):
minv.append(1.0e77)
maxv.append(-1.0e77)
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
mins, maxs = minmax(slab)
minv[i] = float(minimum(float(minv[i]), float(mins)))
maxv[i] = float(maximum(float(maxv[i]), float(maxs)))
if isinstance(min, list) or isinstance(max, list):
for i in range(len(self.vcs_self.animate_info)):
try:
minv.append(min[i])
except:
minv.append(min[-1])
try:
maxv.append(max[i])
except:
maxv.append(max[-1])
else:
for i in range(len(self.vcs_self.animate_info)):
minv.append(min)
maxv.append(max)
# Set the min an max for each plot in the page. If the same graphics method is used
# to display the plots, then the last min and max setting of the
# data set will be used.
for i in range(len(self.vcs_self.animate_info)):
try:
self.set_animation_min_max(minv[i], maxv[i], i)
except:
# if it is default, then you cannot set the min and max, so
# pass.
pass
if save_file is None or save_file.split('.')[-1].lower() == 'ras':
if thread_it:
thread.start_new_thread(self.vcs_self.canvas.animate_init,
(save_file, ))
else:
self.vcs_self.canvas.animate_init(save_file)
else: # ffmpeg stuff
save_info = self.vcs_self.animate_info
animation_info = self.animate_info_from_python()
slabs = []
templates = []
dpys = []
for i in range(len(self.vcs_self.animate_info)):
dpy, slab = self.vcs_self.animate_info[i]
slabs.append(slab)
dpys.append(dpy)
templates.append(dpy.template)
sh = slabs[0].shape
if dpy.g_type in [
'boxfill',
'isofill',
'isoline',
'meshfill',
'outfill',
'outline',
'taylordiagram',
'vector',
]:
r = len(sh) - 2
else:
r = len(sh) - 1
# now create the list of all previous indices to plot
indices = []
for i in range(r):
this = list(range(sh[i]))
tmp = []
if indices == []:
for k in this:
indices.append([
k,
])
else:
for j in range(len(indices)):
for k in this:
tmp2 = copy.copy(indices[j])
tmp2.append(k)
tmp.append(tmp2)
indices = tmp
count = 1
white_square = self.vcs_self.createfillarea()
white_square.color = 240
white_square.x = [0, 1, 1, 0]
white_square.y = [0, 0, 1, 1]
new_vcs = self.vcs_self
if self.vcs_self.orientation() == 'portrait':
new_vcs.portrait()
# self.vcs_self.close()
for index in indices:
new_vcs.clear()
new_vcs.plot(white_square, bg=1)
for i in range(len(save_info)):
slab = slabs[i]
template = templates[i]
gtype = animation_info["gtype"][i].lower()
gname = animation_info["gname"][i]
gm = None # for flake8 to be happy
exec("gm = new_vcs.get%s('%s')" % (gtype, gname))
for j in index:
slab = slab[j]
new_vcs.plot(slab, gm, new_vcs.gettemplate(template), bg=1)
new_vcs.png("tmp_anim_%i" % count)
count += 1
new_vcs.ffmpeg(save_file,
"tmp_anim_%d.png",
bitrate=bitrate,
rate=rate,
options=ffmpegoptions)
for i in range(count - 1):
os.remove("tmp_anim_%i.png" % (i + 1))
del (new_vcs)
self.create_flg = 1
def writeOutput(infile, var, lat, lon, dav, dmax, dmin, sdupper, sdlower, location):
"""
Writes an output file of the variables generated.
"""
location=location.replace(" ","_").lower()
f=cdms.open(infile)
mapit={"apcp":("rainfall","l/m^2"), "tmpk":("temperature","K")}
varname=mapit[var][0]
units=mapit[var][1]
datetime=os.path.split(infile)[-1].split(".")[1]
outfile="%s_%s_%s.nc" % (datetime, location, varname)
outpath=os.path.split(infile)[0]
outfile=os.path.join(outpath, outfile)
fout=cdms.open(outfile, "w")
latax=cdms.createAxis([lat])
latax.units="degrees_north"
latax.id=latax.standard_name=latax.long_name="latitude"
lonax=cdms.createAxis([lon])
lonax.units="degrees_east"
lonax.id=lonax.standard_name=lonax.long_name="longitude"
tax=f[var].getTime() #f(var, level=slice(0,1), lat=slice(0,1), lon=slice(0,1)).getTime()
timeax=cdms.createAxis(Numeric.array(tax[0:tlen],'d'))
timeax.designateTime()
timeax.units=tax.units
#timeax.id=timeax.standard_name=timeax.long_name="time"
timeax.id="time"
timeax.title=tax.title
timeax.delta_t=tax.delta_t
timeax.init_time=tax.init_time
timeax.actual_range=tax.actual_range
del timeax.axis
del timeax.calendar
metadata=f[var]
fv=metadata.missing_value
newshape=(len(timeax), len(latax), len(lonax))
maxFound=20. # Set as our max value if not greater
for v in ((dav, "average"), (dmax, "maximum"), (dmin, "minimum"), \
(sdupper, "plus_std_dev"), (sdlower, "minus_std_dev"), ("always10", "always10")):
if type(v[0])==type("jlj") and v[0]=="always10":
print "Creating always equal to 10 variable."
always10=MA.zeros(newshape, 'f')+10.
#print always10.shape, dav.shape, type(dav)
newvar=cdms.createVariable(always10, axes=[timeax, latax, lonax], id=v[1], fill_value=fv)
newvar.longname="always10"
else:
data=v[0]
name=varname+"_"+v[1]
if not type(data)==type([1,2]):
data=data(squeeze=1)
data=MA.resize(data, newshape)
newvar=cdms.createVariable(data, axes=[timeax, latax, lonax], id=name, fill_value=fv)
newvar.long_name="%s - %s" % (varname.title(), v[1].replace("_", " "))
newvar.units=metadata.units
(dummy,vmax)=vcs.minmax(newvar)
if vmax>maxFound:
maxFound=vmax
fout.write(newvar)
fout.sync()
del newvar
fout.close()
return (outfile, varname, datetime, maxFound)
def _plotInternal(self):
prepedContours = self._prepContours()
tmpLevels = prepedContours["tmpLevels"]
tmpIndices = prepedContours["tmpIndices"]
tmpColors = prepedContours["tmpColors"]
tmpOpacities = prepedContours["tmpOpacities"]
style = self._gm.fillareastyle
# self._patternActors = []
mappers = []
luts = []
geos = []
wholeDataMin, wholeDataMax = vcs.minmax(self._originalData1)
plotting_dataset_bounds = self.getPlottingBounds()
x1, x2, y1, y2 = plotting_dataset_bounds
_colorMap = self.getColorMap()
self._patternActors = []
for i, l in enumerate(tmpLevels):
# Ok here we are trying to group together levels can be, a join
# will happen if: next set of levels contnues where one left off
# AND pattern is identical
# TODO this should really just be a single polydata that is
# colored by scalars:
for j, color in enumerate(tmpColors[i]):
mapper = vtk.vtkPolyDataMapper()
lut = vtk.vtkLookupTable()
th = vtk.vtkThreshold()
th.ThresholdBetween(l[j], l[j + 1])
th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
geoFilter2 = vtk.vtkDataSetSurfaceFilter()
geoFilter2.SetInputConnection(th.GetOutputPort())
# Make the polydata output available here for patterning later
geoFilter2.Update()
geos.append(geoFilter2)
mapper.SetInputConnection(geoFilter2.GetOutputPort())
lut.SetNumberOfTableValues(1)
r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color)
if style == 'solid':
tmpOpacity = tmpOpacities[j]
if tmpOpacity is None:
tmpOpacity = a / 100.
else:
tmpOpacity = tmpOpacities[j] / 100.
lut.SetTableValue(
0, r / 100., g / 100., b / 100., tmpOpacity)
else:
lut.SetTableValue(0, 1., 1., 1., 0.)
mapper.SetLookupTable(lut)
mapper.SetScalarRange(l[j], l[j + 1])
luts.append([lut, [l[j], l[j + 1], True]])
# Store the mapper only if it's worth it?
# Need to do it with the whole slab min/max for animation
# purposes
if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax):
mappers.append(mapper)
# Since pattern creation requires a single color, assuming the
# first
c = self.getColorIndexOrRGBA(_colorMap, tmpColors[i][0])
act = fillareautils.make_patterned_polydata(geoFilter2.GetOutput(),
fillareastyle=style,
fillareaindex=tmpIndices[i],
fillareacolors=c,
fillareaopacity=tmpOpacities[i],
size=(x2 - x1, y2 - y1))
if act is not None:
self._patternActors.append(act)
self._resultDict["vtk_backend_luts"] = luts
if len(geos) > 0:
self._resultDict["vtk_backend_geofilters"] = geos
"""
numLevels = len(self._contourLevels)
if mappers == []: # ok didn't need to have special banded contours
mapper = vtk.vtkPolyDataMapper()
mappers = [mapper]
# Colortable bit
# make sure length match
while len(self._contourColors) < numLevels:
self._contourColors.append(self._contourColors[-1])
lut = vtk.vtkLookupTable()
lut.SetNumberOfTableValues(numLevels)
for i in range(numLevels):
r, g, b, a = self._colorMap.index[self._contourColors[i]]
lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.)
mapper.SetLookupTable(lut)
if numpy.allclose(self._contourLevels[0], -1.e20):
lmn = self._min - 1.
else:
lmn = self._contourLevels[0]
if numpy.allclose(self._contourLevels[-1], 1.e20):
lmx = self._max + 1.
else:
lmx = self._contourLevels[-1]
mapper.SetScalarRange(lmn, lmx)
self._resultDict["vtk_backend_luts"] = [[lut, [lmn, lmx, True]]]
"""
if self._maskedDataMapper is not None:
# Note that this is different for meshfill -- others prepend.
mappers.append(self._maskedDataMapper)
# Add a second mapper for wireframe meshfill:
if self._gm.mesh:
lineMappers = []
wireLUT = vtk.vtkLookupTable()
wireLUT.SetNumberOfTableValues(1)
wireLUT.SetTableValue(0, 0, 0, 0)
for polyMapper in mappers:
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(
polyMapper.GetInputConnection(0, 0))
lineMapper._useWireFrame = True
# 'noqa' comments disable pep8 checking for these lines. There
# is not a readable way to shorten them due to the unwieldly
# method name.
#
# Setup depth resolution so lines stay above points:
polyMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(0, 1) # noqa
polyMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetResolveCoincidentTopologyPolygonOffsetParameters(1, 1) # noqa
lineMapper.SetResolveCoincidentTopologyToPolygonOffset()
lineMapper.SetLookupTable(wireLUT)
lineMappers.append(lineMapper)
mappers.extend(lineMappers)
# And now we need actors to actually render this thing
actors = []
vp = self._resultDict.get(
'ratio_autot_viewport',
[self._template.data.x1, self._template.data.x2,
self._template.data.y1, self._template.data.y2])
dataset_renderer = None
xScale, yScale = (1, 1)
for mapper in mappers:
act = vtk.vtkActor()
act.SetMapper(mapper)
if hasattr(mapper, "_useWireFrame"):
prop = act.GetProperty()
prop.SetRepresentationToWireframe()
if self._vtkGeoTransform is None:
# If using geofilter on wireframed does not get wrppaed not
# sure why so sticking to many mappers
act = vcs2vtk.doWrap(act, plotting_dataset_bounds,
self._dataWrapModulo)
# TODO See comment in boxfill.
if mapper is self._maskedDataMapper:
actors.append([act, self._maskedDataMapper, plotting_dataset_bounds])
else:
actors.append([act, plotting_dataset_bounds])
# create a new renderer for this mapper
# (we need one for each mapper because of cmaera flips)
dataset_renderer, xScale, yScale = self._context().fitToViewport(
act, vp,
wc=plotting_dataset_bounds, geoBounds=self._vtkDataSet.GetBounds(),
geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=(dataset_renderer is None))
for act in self._patternActors:
if self._vtkGeoTransform is None:
# If using geofilter on wireframed does not get wrapped not sure
# why so sticking to many mappers
self._context().fitToViewport(
act, vp,
wc=plotting_dataset_bounds, geoBounds=self._vtkDataSet.GetBounds(),
geo=self._vtkGeoTransform,
priority=self._template.data.priority,
create_renderer=True)
actors.append([act, plotting_dataset_bounds])
self._resultDict["vtk_backend_actors"] = actors
kwargs = {"vtk_backend_grid": self._vtkDataSet,
"dataset_bounds": self._vtkDataSetBounds,
"plotting_dataset_bounds": plotting_dataset_bounds,
"vtk_backend_geo": self._vtkGeoTransform}
if ("ratio_autot_viewport" in self._resultDict):
kwargs["ratio_autot_viewport"] = vp
self._template.plot(self._context().canvas, self._data1, self._gm,
bg=self._context().bg,
X=numpy.arange(min(x1, x2),
max(x1, x2) * 1.1,
abs(x2 - x1) / 10.),
Y=numpy.arange(min(y1, y2),
max(y1, y2) * 1.1,
abs(y2 - y1) / 10.), **kwargs)
legend = getattr(self._gm, "legend", None)
if self._gm.ext_1:
if isinstance(self._contourLevels[0], list):
if numpy.less(abs(self._contourLevels[0][0]), 1.e20):
# Ok we need to add the ext levels
self._contourLevels.insert(
0, [-1.e20, self._contourLevels[0][0]])
else:
if numpy.less(abs(self._contourLevels[0]), 1.e20):
# need to add an ext
self._contourLevels.insert(0, -1.e20)
if self._gm.ext_2:
if isinstance(self._contourLevels[-1], list):
if numpy.less(abs(self._contourLevels[-1][1]), 1.e20):
# need ext
self._contourLevels.append([self._contourLevels[-1][1],
1.e20])
else:
if numpy.less(abs(self._contourLevels[-1]), 1.e20):
# need exts
self._contourLevels.append(1.e20)
patternArgs = {}
patternArgs['style'] = self._gm.fillareastyle
patternArgs['index'] = self._gm.fillareaindices
if patternArgs['index'] is None:
patternArgs['index'] = [1, ]
patternArgs['opacity'] = self._gm.fillareaopacity
self._resultDict.update(
self._context().renderColorBar(self._template, self._contourLevels,
self._contourColors,
legend,
self.getColorMap(),
**patternArgs))
if self._context().canvas._continents is None:
self._useContinents = False
if self._useContinents:
projection = vcs.elements["projection"][self._gm.projection]
continents_renderer, xScale, yScale = self._context().plotContinents(
plotting_dataset_bounds, projection,
self._dataWrapModulo,
vp, self._template.data.priority,
vtk_backend_grid=self._vtkDataSet,
dataset_bounds=self._vtkDataSetBounds)
def return_animation_min_max(self):
dpy, slab = self.vcs_self.animate_info[0]
return vcs.minmax(slab)
