def run(self, custom_classfy):
"""
遍历config文件和音频路径，将其新平台文本格式信息写到output/result.txt文件中
:param custom_classfy: 自定义分包条数，默认按spk音频数分包
"""
logger.debug('遍历wav_name,text信息')
wav_suf = 'wav'
counter = 0
wavs_info_map = {}
for SPK, wav_name, content in self.get_info(): # 遍历说话人id，音频名，音频内容 信息
logger.debug('[wav_info] %s - %s - %s ' % (SPK, wav_name, content))
if wav_name not in self.wav_time_map:
logger.warning('[%s] 未找到音频' % wav_name)
continue
wav_time = self.wav_time_map.get(wav_name)
if not wav_time:
continue
wav_info = [ # 填充新平台文本格式
{
"Wav_name": wav_name,
"Length_time": wav_time,
"Data": [
{
"text": content,
"start_time": 0,
"end_time": wav_time
}
],
"Wav_suf": wav_suf
}
]
if custom_classfy: # 指定分包数的模式
id = f'line_{counter}'
if id not in wavs_info_map:
wavs_info_map[id] = [wav_info]
else:
if len(wavs_info_map[id]) == custom_classfy - 1:
counter += 1
wavs_info_map[id].append(wav_info)
else: # 默认分包模式
if SPK not in wavs_info_map:
wavs_info_map[SPK] = [wav_info]
else:
wavs_info_map[SPK].append(wav_info)
logger.info(
'处理完毕！ 共 %s 批次 [%s]' % (len(wavs_info_map.keys()), wavs_info_map.keys()) if not custom_classfy else (
counter, len(reduce(lambda x, y: x + y, wavs_info_map.values()))))
with open(self._save_path, 'w', encoding='utf-8') as f:
for key, value in wavs_info_map.items():
f.write(json.dumps(value, ensure_ascii=False) + '\n')
def advanced_prompt(self):
logger.info('Opening advanced search window')
if (not AdvancedSearchDialog.singleton):
AdvancedSearchDialog(self, self.__root). \
wm_iconbitmap(ICO)
else:
logger.warning('Found existing advanced search window, canceling')
def close_polygon(self, event, plot, fl, fig, fill=False):
if len(self.__coordinates) > 3:
index = self.__can_draw()
if index > -1:
logger.debug("Creating polygon from points")
a1 = tuple_to_nparray(self.__coordinates[index])
a2 = tuple_to_nparray(self.__coordinates[index + 1])
b1 = tuple_to_nparray(self.__coordinates[-1])
b2 = tuple_to_nparray(self.__coordinates[-2])
x = get_intersection(a1, a2, b1, b2)
pair = nparray_to_tuple(x)
self.__coordinates[index] = pair
del self.__coordinates[:index]
self.__coordinates.pop()
for line in self.__lines:
line.remove()
self.__drawing_line.remove()
self.__drawing_line = None
self.__lines = []
self.draw(fig, plot, fill)
self.__plot = plot
self.__hdf = fl
return True
else:
logger.warning('Not enough points')
def close(self):
"""
Checks if the all the shapes are saved. If a shape is unsaved, the
program will ask the user whether save or not, and then close the
program. Also saves the session settings to the config.json file
"""
logger.info('Writing session settings')
CONF.opened.change(True)
CONF.write_config()
if not self.__shapemanager.is_all_saved():
logger.warning('Unsaved shapes found')
answer = tkMessageBox. \
askyesnocancel('Close Without Saving',
'There are unsaved shapes on the plot. Save these shapes?')
if answer is True:
logger.info('Saving shapes')
saved = self.save_json()
if saved:
error_check()
self.__root.destroy()
else:
return
elif answer is False:
logger.info('Dumping unsaved shapes')
error_check()
self.__root.destroy()
elif answer is None:
return
else:
error_check()
self.__root.destroy()
def fill_rectangle(self, event):
"""
Informs the correct shape list's blank object to draw a rectangle to the screen
using the provided coordinates
:param event: A backend passed ``matplotlib.backend_bases.MouseEvent`` object
"""
if self.__current_plot == Plot.baseplot:
logger.warning("Cannot draw to BASE_PLOT")
return
if event.xdata and event.ydata:
if len(self.__current_list[-1].get_coordinates()) is 0:
return
logger.debug('Filling: %d, %d' % (event.xdata, event.ydata))
logger.info('Creating rectangle')
self.__current_list[-1].fill_rectangle(event, self.__current_plot,
self.__hdf, self.__figure,
ShapeManager.outline_toggle)
self.__current_list[-1].set_tag(self.generate_tag())
self.__current_list.append(Shape(self.__canvas))
self.__canvas.show()
else:
logger.error('Bounds out of plot range, skipping')
self.__current_list[-1].set_coordinates([])
self.__canvas._tkcanvas.delete(self.__current_list[-1].lastrect)
def plot_point(self, event):
"""
Plot a single point to the screen for the current shape object,
if other points exist, a line is drawn between then until a
polygon is formed
:param event: A ``matplotlib.backend_bases.MouseEvent`` passed object
"""
if self.__current_plot == Plot.baseplot:
logger.warning('Cannot draw to the base plot')
return
if event.xdata and event.ydata:
logger.info('Plotting point at %.5f, %.5f' %
(event.xdata, event.ydata))
check = self.__current_list[-1].plot_point(
event, self.__current_plot, self.__hdf, self.__figure,
ShapeManager.outline_toggle)
self.__drawing = True
if check:
self.__current_list[-1].set_tag(self.generate_tag())
self.__current_list.append(Shape(self.__canvas))
self.__drawing = False
self.__canvas.show()
else:
logger.error("Point to plot is out or range, skipping")
def interpolation_search(sorted_list, to_find, variance):
"""
Interpolation search algorithm for determining the location of the
point according to sorted_list, the sorted_list has a constant step
and can thus give this algorithm the complexity of just ``O(log log(n))``
:param list sorted_list: The sorted list to search in
:param float to_find: The point to find
:param float variance: A constant variance allowed for finding the point
:rtype: float
"""
low = 0
high = len(sorted_list) - 1
while sorted_list[low] <= to_find <= sorted_list[high]:
mid = int(low + ((to_find - sorted_list[low]) * (high - low)) /
(sorted_list[high] - sorted_list[low]))
if sorted_list[mid] < to_find:
low = mid + 1
elif sorted_list[mid] > to_find:
high = mid - 1
else:
return mid
t_var = variance
while abs(sorted_list[low] - to_find) > variance:
t_var += .001
if variance != t_var:
logger.warning(
"interpolation variance expanded to %f to meet requirements" %
variance)
logger.debug("Interpolation low: %s", low)
return low
def set_plot(self, plot):
"""
Determine which list current_list should alias, also set internal plot
variable
:param constants.Plot plot: Acceptable plot constant from ``constants.py``
"""
if plot == Plot.baseplot:
logger.warning('set_plot called for BASE_PLOT')
self.__current_list = self.__shape_list[Plot.baseplot]
self.__current_plot = Plot.baseplot
elif plot == Plot.backscattered:
logger.info('set_plot to BACKSCATTERED')
self.__current_list = self.__shape_list[Plot.backscattered]
self.__current_plot = Plot.backscattered
elif plot == Plot.depolarized:
logger.info('set_plot to DEPOLARIZED')
self.__current_list = self.__shape_list[Plot.depolarized]
self.__current_plot = Plot.depolarized
elif plot == Plot.vfm:
logger.info('set_plot to VFM')
self.__current_list = self.__shape_list[Plot.vfm]
self.__current_plot = Plot.vfm
elif plot == Plot.iwp:
logger.info('set_plot to IWP')
self.__current_list = self.__shape_list[Plot.iwp]
self.__current_plot = Plot.iwp
elif plot == Plot.horiz_avg:
logger.info('set_plot to HORIZ_AVG')
self.__current_list = self.__shape_list[Plot.horiz_avg]
self.__current_plot = Plot.horiz_avg
elif plot == Plot.horiz_avg:
logger.info('set_plot to AEROSOL SUBTYPE')
self.__current_list = self.__shape_list[Plot.aerosol_subtype]
self.__current_plot = Plot.aerosol_subtype
def save_json(self, filename=''):
"""
Save all shapes selected on the screen to a specified JSON object,
if no file is passed the internal file variable is used. There should **never**
arise a case where no file is passed either from the internal or external
parameters, ``Calipso`` has proper error checking.
:param str filename: custom filename to save JSON objects to
"""
if filename != '':
self.__current_file = filename
if not self.__selected_shapes:
logger.warning('No shapes selected, saving empty plot')
today = datetime.utcnow().replace(microsecond=0)
self.__data['time'] = str(today)
self.__data['hdffile'] = self.__hdf.rpartition('/')[2]
shape_dict = {}
for i in range(len(self.__shape_list)):
self.__data[constants.PLOTS[i]] = {}
i = self.__shape_list.index(self.__current_list)
for j in range(len(self.__selected_shapes)):
if not self.__selected_shapes[j].get_saved():
self.__selected_shapes[j].save()
tag = self.__selected_shapes[j].get_tag()
coordinates = self.__selected_shapes[j].get_coordinates()
color = self.__selected_shapes[j].get_color()
attributes = self.__selected_shapes[j].get_attributes()
note = self.__selected_shapes[j].get_notes()
_id = self.__selected_shapes[j].get_id()
time_cords = [mpl.dates.num2date(x[0]) for x in coordinates]
alt_cords = [x[1] for x in coordinates]
blat = self.__selected_shapes[j].get_min_lat()
elat = self.__selected_shapes[j].get_max_lat()
btime = min(time_cords).strftime(DATEFORMAT)
etime = max(time_cords).strftime(DATEFORMAT)
balt = min(alt_cords)
ealt = max(alt_cords)
value = {
'coordinates': coordinates,
'blat': blat,
'elat': elat,
'btime': btime,
'etime': etime,
'balt': balt,
'ealt': ealt,
'color': color,
'attributes': attributes,
'notes': note,
'id': _id
}
shape_dict[tag] = value
self.__data[constants.PLOTS[i]] = shape_dict
logger.info('Encoding to JSON')
db.encode(self.__current_file, self.__data)
def __init__(self, username=None, password=None, project_name=None, token=None, admin=False):
super().__init__(username, password, project_name, token, admin)
self.nova = client.Client(2, session=self.sess)
self.neutron = client_neutron.Client(session=self.sess)
self.cinder = client_cinder.Client(3, session=self.sess)
self.glance = Client(2, session=self.sess)
try:
self.services = self.nova.services.list()
self.hypervisors = self.nova.hypervisors.list()
except Exception as e:
logger.warning(e)
def import_dialog(self):
"""
Open the database import window allowing the user to import and
delete entries.
"""
logger.info('Opening database import window')
if (not ImportDialog.singleton):
ImportDialog(self.__root, self). \
wm_iconbitmap(ICO)
else:
logger.warning('Found existing import window, canceling')
def settings_dialog(self):
"""
Opens the settings window allowing the user to manually change the settings in the config
file
"""
logger.info('Opening settings window')
if (not SettingsDialog.singleton):
SettingsDialog(self.__root, self). \
wm_iconbitmap(ICO)
else:
logger.warning('Found existing settings window, canceling')
def anchor_rectangle(self, event):
"""
Informs the correct shape list's blank object to plot a corner of a rectangle.
:param event: A backend passed ``matplotlib.backend_bases.MouseEvent`` object
"""
if self.__current_plot == Plot.baseplot:
logger.warning("Cannot draw to BASE_PLOT")
return
if event.xdata and event.ydata:
logger.info('Anchoring %d, %d' % (event.xdata, event.ydata))
self.__current_list[-1].anchor_rectangle(event)
else:
logger.error('Anchor selected is out of range, skipping')
def __can_draw(self):
if not self.__coordinates:
logger.warning('Attempting to ask to draw empty shape, probably just ' + \
'toggling a button after using free draw? See ticket #92')
return -1
b1 = tuple_to_nparray(self.__coordinates[-1])
b2 = tuple_to_nparray(self.__coordinates[-2])
for i in range(len(self.__coordinates) - 3):
a1 = tuple_to_nparray(self.__coordinates[i])
a2 = tuple_to_nparray(self.__coordinates[i + 1])
if is_intersecting(a1, a2, b1, b2):
logger.debug("Polygon labeled for draw")
return i
return -1
def rubberband(self, event):
"""
Uses a blank shape to draw 'helper rectangles' that outline the final shape of the
object. wrapper function for calling :py:class:`polygon.Shape` method.
:param event: A backend passes ``matplotlib.backend_bases.MouseEvent`` object
"""
if event.button == 1:
if self.__current_plot == Plot.baseplot:
logger.warning("Cannot draw to BASE_PLOT")
return
if len(self.__current_list[-1].get_coordinates()) is 0:
return
self.__current_list[-1].rubberband(event)
def properties(self, event):
"""
Return the properties.rst of the shape clicked on by the user and create a small
tooltip which displays these properties.rst
:param event: A passed ``matplotlib.backend_bases.PickEvent`` object
"""
target = event.artist
logger.debug("Creating property window")
for shape in self.__current_list:
if shape.get_itemhandler() is target:
# if self.property_window is not None:
# self.destroy_property_window()
PropertyDialog(self.__master.get_root(), shape)
return
logger.warning("Shape not found")
def pack_shape(self, shape_list, plot_type, canvas, read_from_str=None):
"""
Stores the data in the JSON into PolygonDrawers
:param shape_list: a Python list of PolygonDrawers
:param plot_type: the current plot being displayed
:param canvas: a Tkinter canvas to initialize the blank PolygonDrawer in the shape_list
"""
from polygon.manager import ShapeManager
enum_plot_type = constants.plot_type_enum[plot_type]
try:
for shape in self.__data[plot_type]:
entry = self.__data[plot_type][shape]['id']
if entry is not None and int(entry) in [x.get_id() for x in shape_list]:
continue
logger.info('Found data in %s, packing polygon with JSON data'
% PLOTS[enum_plot_type])
color = self.__data[plot_type][shape]['color']
#fl = self.__data['hdffile']
coordinates = self.__data[plot_type][shape]['coordinates']
attributes = self.__data[plot_type][shape]['attributes']
notes = self.__data[plot_type][shape]['notes']
_id = self.__data[plot_type][shape]['id']
if db.exists_tag(shape) and not read_from_str:
new = ShapeManager.generate_tag()
logger.warning(
'Shape tag already exists in database, creating new tag % s'
% new)
shape_list[-1].set_tag(new)
else:
shape_list[-1].set_tag(shape)
shape_list[-1].set_id(_id)
shape_list[-1].set_color(color)
shape_list[-1].set_plot(enum_plot_type)
#shape_list[-1].set_hdf(fl)
shape_list[-1].set_attributes(attributes)
shape_list[-1].set_coordinates(coordinates)
shape_list[-1].set_notes(notes)
shape_list[-1].save()
shape_list.append(Shape(canvas))
except KeyError:
logger.error('Bad data in JSON file')
def get_current_file_shapes(self):
"""
Return a list of all shapes contained in the current file, queries the
database looking for all entries with the column *tag* that match the
file returned by the rpartitioned ``Calipso.get_file()`` function
:rtype: list
"""
fn = self.__master.get_file().rpartition('/')[2]
lst = list()
for obj in self.session.query(DatabasePolygon).filter_by(hdf=fn):
time_range = '%s - %s' % (obj.begin_time.strftime(DATEFORMAT),
obj.end_time.strftime('%H:%M:%S'))
altitude_range = '%.3f - %.3f' % (obj.begin_alt, obj.end_alt)
lat_range = '%.3f - %.3f' % (obj.begin_lat, obj.end_lat)
lst.append((obj.tag, obj.plot, time_range, lat_range,
altitude_range, obj.attributes[1:-1], obj.notes,
obj.time_.strftime(DATEFORMAT), obj.hdf))
if not lst:
logger.warning('Query returned None, no shapes found')
return lst
def render_pan(self, event):
"""
Saves ending coordinates of mouse press and proceeds to find the distance
between the two points, scrolls the map accordingly
:param event: Tkinter passed event object
"""
logger.info('Pan point 2, finding distance and panning...')
# Find distance and add an amplifier of 1.5
dst = int(distance(self.panx, self.pany, event.x, event.y) * 1.5)
# If the user is scrolling backwards
if self.panx < event.x:
# Already at beginning
if self.xrange[0] == 0:
logger.warning(
'Attempting to pan backwards, already at beginning nothing to be done'
)
return
# The end position would be negative
if self.xrange[0] - dst < 0:
logger.warning(
'Attempting to pan past beginning, setting to beginning')
# Set both xrange and dst to zero and simply reload beginning range
self.xrange = (0, self.xrange[1])
dst = 0
self.set_plot(self.plot,
(self.xrange[0] - dst, self.xrange[1] - dst))
logger.info('Panning backwards')
else:
logger.info('Panning forwards')
self.set_plot(self.plot,
xrange_=(self.xrange[0] + dst, self.xrange[1] + dst),
yrange=(int(
self.__child.begin_alt_range_entry.get()),
int(self.__child.end_alt_range_entry.get())))
self.__child.begin_range_entry.delete(0, END)
self.__child.end_range_entry.delete(0, END)
self.__child.begin_range_entry.insert(END, str(self.xrange[0]))
self.__child.end_range_entry.insert(END, str(self.xrange[1]))
def acquire_time(wav_path):
"""
获取音频时长
:param wav_path: 音频路径
:return: 音频时长
"""
# if re.match('.*?sox.*', os.getenv('PATH')): # 判断环境变量里是否有sox
cmd = 'sox --i -D %s' % wav_path
logger.debug('[cmd]%s' % cmd)
p = subprocess.Popen(
cmd, # 使用sox计算音频时长
stdout=subprocess.PIPE,
shell=True,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
out = p.stdout.read().decode()
err = p.stderr.read().decode()
if out and re.match('[0-9.]+', out) and not err: # 判断sox是否成功
logger.debug('[out] %s' % out)
wav_time = float(out)
return wav_time
else:
logger.debug('[err] %s' % err)
logger.warning('[%s] 文件未能通过sox统计时长 ' % wav_path)
try:
with contextlib.closing(wave.open(wav_path, 'r')) as f:
frames = f.getnframes()
rate = f.getframerate()
duration = frames / float(rate)
return duration
except Exception:
pass
# raise CustomError('[%s] 未能获取音频时长，请检查音频格式') from None
return None
def set_plot(self, plot_type, xrange_=(0, 1000), yrange=(0, 20)):
"""
Draws to the canvas according to the *plot_type* specified in the arguments. Accepts one of
the attributes below
.. py:attribute:: BASE_PLOT
.. py:attribute:: BACKSCATTERED
.. py:attribute:: DEPOLARIZED
.. py:attribute:: VFM
.. py:attribute:: IWP
.. py:attribute:: HORIZ_AVG
.. py:attribute:: AEROSOL_SUBTYPE
:param int plot_type: accepts ``BASE_PLOT, BACKSCATTERED, DEPOLARIZED, VFM, IWP, HORIZ_AVG
:param list xrange\_: accepts a range of time to plot
:param list yrange: accepts a range of altitude to plot
"""
self.xrange = xrange_
self.yrange = yrange
if plot_type == Plot.baseplot:
# Hide the axis and print an image
self.__shapemanager.set_plot(Plot.baseplot)
im = mpimg.imread(PATH + '/dat/CALIPSO.jpg')
self.__fig.get_yaxis().set_visible(False)
self.__fig.get_xaxis().set_visible(False)
self.__fig.imshow(im)
elif plot_type == Plot.backscattered:
try:
# Clear any references to the current figure, construct a new figure
# and render the backscattered plot to it
logger.info('Setting plot to backscattered xrange: ' +
str(xrange_) + ' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(1)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_backscattered(self.__file, xrange_, yrange,
self.__fig,
self.__parent_fig)
self.__shapemanager.set_current(Plot.backscattered, self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.backscattered
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', 'No File Exists')
except IndexError:
tkMessageBox.showerror('Backscattered Plot',
'Index out of bounds')
elif plot_type == Plot.depolarized:
try:
# Clear any references to the current figure, construct a new figure
# and render the depolarized plot to it
logger.info('Setting plot to depolarized xrange: ' +
str(xrange_) + ' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(1)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_depolarized(self.__file, xrange_, yrange,
self.__fig, self.__parent_fig)
self.__shapemanager.set_current(Plot.depolarized, self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.depolarized
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', "No File Exists")
elif plot_type == Plot.vfm:
try:
# Clear any references to the current figure, construct a new figure
# and render the depolarized plot to it
logger.info('Setting plot to vfm xrange: ' + str(xrange_) +
' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(2)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_vfm(self.__file, xrange_, yrange,
self.__fig, self.__parent_fig)
self.__shapemanager.set_current(Plot.vfm, self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.vfm
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', "No File Exists")
elif plot_type == Plot.iwp:
try:
# Clear any references to the current figure, construct a new figure
# and render the depolarized plot to it
logger.info('Setting plot to iwp xrange: ' + str(xrange_) +
' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(2)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_iwp(self.__file, xrange_, yrange,
self.__fig, self.__parent_fig)
self.__shapemanager.set_current(Plot.iwp, self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.iwp
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', "No File Exists")
elif plot_type == Plot.horiz_avg:
try:
# Clear any references to the current figure, construct a new figure
# and render the depolarized plot to it
logger.info('Setting plot to horiz_avg xrange: ' +
str(xrange_) + ' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(2)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_horiz_avg(self.__file, xrange_, yrange,
self.__fig, self.__parent_fig)
self.__shapemanager.set_current(Plot.horiz_avg, self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.horiz_avg
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', "No File Exists")
elif plot_type == Plot.aerosol_subtype:
try:
# Clear any references to the current figure, construct a new figure
# and render the depolarized plot to it
logger.info('Setting plot to aerosol_subtype xrange: ' +
str(xrange_) + ' yrange: ' + str(yrange))
self.__file = self.__data_block.get_file_name(2)
logger.info('Using file ' + self.__file)
# Reset if the file is not empty AND we are using granules from different time/place
if self.__shapemanager.get_hdf() != '' and \
self.__file[-25:-4] != self.__shapemanager.get_hdf()[-25:-4]:
self.__shapemanager.reset(all_=True)
else:
self.__shapemanager.clear_refs()
self.__shapemanager.set_hdf(self.__file)
self.__parent_fig.clear()
self.__fig = self.__parent_fig.add_subplot(1, 1, 1)
self.__fig = render_aerosol_subtype(self.__file, xrange_,
yrange, self.__fig,
self.__parent_fig)
self.__shapemanager.set_current(Plot.aerosol_subtype,
self.__fig)
self.__drawplot_canvas.show()
self.__toolbar.update()
self.plot = Plot.aerosol_subtype
except IOError:
logger.error('IOError, no file exists')
tkMessageBox.showerror('File Not Found', "No File Exists")
else:
logger.warning('Plot Type not yet supported')
