def traits_view(self): twodgrp = VGroup(HGroup(Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels')), Item('model_kind'), visible_when='plot_kind=="2D"') onedgrp = VGroup(Item('marker_size'), visible_when='plot_kind=="1D"') # ogrp = HGroup(Item('confirm_save', # label='Confirm Save', tooltip='Allow user to review evolutions ' # 'before saving to file')) grp = VGroup(Item('plot_kind'), twodgrp, onedgrp, Item('selected_decay', label='Decay Const.'), Readonly('lambda_k', label=u'Total \u03BB K'), Item('monitor_age'), Item('predicted_j_error_type', ), Item('use_weighted_fit', ), Item('monte_carlo_ntrials', ), Item('use_monte_carlo', ), label='Fits', show_border=True) return self._make_view(grp)
def traits_view(self): twodgrp = VGroup(HGroup( Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels')), Item('model_kind'), visible_when='plot_kind=="2D"') onedgrp = VGroup(Item('marker_size'), visible_when='plot_kind=="1D"') # ogrp = HGroup(Item('confirm_save', # label='Confirm Save', tooltip='Allow user to review evolutions ' # 'before saving to file')) grp = VGroup(Item('plot_kind'), twodgrp, onedgrp, Item('selected_decay', label='Decay Const.'), Readonly('lambda_k', label=u'Total \u03BB K'), Item('monitor_age'), Item('predicted_j_error_type', ), Item('use_weighted_fit', ), Item('monte_carlo_ntrials', ), Item('use_monte_carlo', ), label='Fits', show_border=True) return self._make_view(grp)
def traits_view(self): contour_grp = HGroup(Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels'), Item('marker_size'), visible_when='plot_kind=="Contour"') monitor_grp = Item('monitor', editor=EnumEditor(name='monitors')) v = View( VGroup(HGroup(UItem('calculate_button'), UItem('data_source', editor=EnumEditor(values=['database', 'file'])), monitor_grp), HGroup(Item('save_mean_j', label='Save Mean J'), Item('auto_clear_cache', label='Auto Clear Cache')), Item('mean_j_error_type', label='Mean J Error'), HGroup(Item('use_weighted_fit'), Item('use_monte_carlo'), Item('monte_carlo_ntrials', enabled_when='object.use_monte_carlo')), Item('predicted_j_error_type', label='Predicted J Error', enabled_when='not (object.use_weighted_fit or object.use_monte_carlo)'), HGroup(Item('group_positions'), Item('object.monitor.sample', style='readonly', label='Sample')), Item('show_labels', label='Display Labels', tooltip='Display hole labels on plot'), HGroup(UItem('plot_kind'), Item('model_kind', label='Fit Model', editor=EnumEditor(values=['Bowl', 'Plane']))), # UItem('plot_kind', editor=EnumEditor(values=['Contour', 'Hole vs J']))), contour_grp)) return v
def traits_view(self): twodgrp = VGroup(HGroup(Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels')), visible_when='plot_kind=="2D"', label='Options', show_border=True) onedgrp = VGroup(Item('marker_size'), visible_when='plot_kind=="1D"', label='Options', show_border=True) scalegrp = VGroup(Item('flux_scalar', label='Scale', tooltip='Multiple flux by Scale. FOR DISPLAY ONLY')) return self._make_view(VGroup(twodgrp, onedgrp, scalegrp))
def traits_view(self): twodgrp = VGroup(HGroup( Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels')), visible_when='plot_kind=="2D"', label='Options', show_border=True) onedgrp = VGroup(Item('marker_size'), visible_when='plot_kind=="1D"', label='Options', show_border=True) scalegrp = VGroup( Item('flux_scalar', label='Scale', tooltip='Multiple flux by Scale. FOR DISPLAY ONLY')) return self._make_view(VGroup(twodgrp, onedgrp, scalegrp))
def traits_view(self): contour_grp = VGroup(Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels'), visible_when='plot_kind=="Contour"') monitor_grp=Item('monitor', editor=EnumEditor(name='monitors')) v = View( VGroup(HGroup(UItem('calculate_button'), UItem('data_source', editor=EnumEditor(values=['database', 'file'])), monitor_grp), HGroup(Item('group_positions'), Item('object.monitor.sample', style='readonly',label='Sample')), HGroup(UItem('plot_kind'), Item('model_kind', label='Fit Model', editor=EnumEditor(values=['Bowl', 'Plane']))), # UItem('plot_kind', editor=EnumEditor(values=['Contour', 'Hole vs J']))), contour_grp)) return v
class IdeogramOptions(AgeOptions): naux_plots = 8 aux_plot_klass = IdeogramAuxPlot edit_label_format_button = Button edit_mean_format_button = Button mean_label_format = Str mean_label_display = Str # edit_label_format = Button # refresh_asymptotic_button = Button index_attrs = Dict(transient=True) probability_curve_kind = Enum('cumulative', 'kernel') mean_calculation_kind = Enum('weighted mean', 'kernel') use_centered_range = Bool use_static_limits = Bool xlow = Float xhigh = Float centered_range = Float(0.5) display_mean_indicator = Bool(True) display_mean = Bool(True) display_mean_mswd = Bool(True) display_mean_n = Bool(True) display_percent_error = Bool(True) # display_identifier_on_mean = Bool(False) # display_sample_on_mean = Bool(False) label_all_peaks = Bool(True) peak_label_sigfigs = Int peak_label_bgcolor = Color peak_label_border = Int peak_label_border_color = Color peak_label_bgcolor_enabled = Bool(False) aux_plot_name = 'Ideogram' use_asymptotic_limits = Bool # asymptotic_width = Float) asymptotic_height_percent = Float analysis_number_sorting = Enum('Oldest @Top', 'Youngest @Top') mean_indicator_font = Property mean_indicator_fontname = Enum(*FONTS) mean_indicator_fontsize = Enum(*SIZES) mean_sig_figs = Enum(*SIG_FIGS) use_cmap_analysis_number = Bool(False) cmap_analysis_number = Enum(list(color_map_name_dict.keys())) use_latest_overlay = Bool(False) show_results_table = Bool(False) show_ttest_table = Bool(False) group_options_klass = IdeogramGroupOptions _use_centered_range = Bool _use_asymptotic_limits = Bool _suppress_xlimits_clear = Bool def initialize(self): self.subview_names = [ MAIN, 'Ideogram', APPEARANCE, 'Calculations', DISPLAY, GROUPS ] def to_dict(self): d = super(IdeogramOptions, self).to_dict() aux_plots = self.to_dict_aux_plots() groups = self.to_dict_groups() d['aux_plots'] = aux_plots d['groups'] = groups return d def to_dict_aux_plots(self): return [ap.to_dict() for ap in self.aux_plots] def to_dict_groups(self): pass def to_dict_test(self, k): return k not in ('_suppress_xlimits_clear', 'aux_plots', 'groups', 'index_attrs') def get_plot_dict(self, group_id, subgroup_id): n = len(self.groups) gid = group_id % n fg = self.groups[gid] line_color = fg.line_color color = fg.color # if subgroup_id: # rgb = color.red(), color.blue(), color.green() # rgb = [c*0.9*subgroup_id for c in rgb] # color.setRgb(*rgb) d = { 'color': color, 'edge_color': line_color, 'edge_width': fg.line_width, 'line_width': fg.line_width, 'line_color': line_color } if fg.use_fill: color = fg.color.toRgb() color.setAlphaF(fg.alpha * 0.01) d['fill_color'] = color d['type'] = 'filled_line' return d # private def _get_subview(self, name): return VIEWS[name] # handlers @on_trait_change('use_static_limits, use_centered_range') def _handle_use_limits(self, new): # persist use asymptotic limits self._suppress_xlimits_clear = True if new: self._use_asymptotic_limits = self.use_asymptotic_limits self.trait_set(use_asymptotic_limits=False) else: self.trait_set(use_asymptotic_limits=self._use_asymptotic_limits) self._suppress_xlimits_clear = False def _use_asymptotic_limits_changed(self, new): # persist use_centered range if not self._suppress_xlimits_clear: if new: self._use_centered_range = self.use_centered_range self.trait_set(use_centered_range=False) else: self.trait_set(use_centered_range=self._use_centered_range) @on_trait_change('xlow, xhigh') def _handle_static_limits(self): for ap in self.aux_plots: ap.clear_xlimits() @on_trait_change( 'use_asymptotic_limits, asymptotic+, use_centered_range, centered_range, use_static_limits' ) def _handle_asymptotic(self, name, new): # if name.startswith('use') and not new: # return if not self._suppress_xlimits_clear: for ap in self.aux_plots: ap.clear_xlimits() def _index_attr_changed(self): for ap in self.aux_plots: ap.clear_ylimits() def _edit_label_format_button_fired(self): from pychron.processing.label_maker import LabelTemplater, LabelTemplateView lm = LabelTemplater(label=self.analysis_label_display) lv = LabelTemplateView(model=lm) info = lv.edit_traits() if info.result: self.analysis_label_format = lm.formatter self.analysis_label_display = lm.label # self.refresh_plot_needed = True def _edit_mean_format_button_fired(self): from pychron.processing.label_maker import MeanLabelTemplater, MeanLabelTemplateView lm = MeanLabelTemplater(label=self.mean_label_display) lv = MeanLabelTemplateView(model=lm) info = lv.edit_traits() if info.result: self.mean_label_format = lm.formatter self.mean_label_display = lm.label def _get_mean_indicator_font(self): return '{} {}'.format(self.mean_indicator_fontname, self.mean_indicator_fontsize) def _index_attrs_default(self): return { 'uage': '01:Age', 'uF': '02:Ar40*/Ar39k', 'Ar40/Ar36': '03:Ar40/Ar36', 'Ar40/Ar39': '04:Ar40/Ar39', 'Ar40/Ar38': '05:Ar40/Ar38', 'Ar39/Ar37': '06:Ar39/Ar37', 'uAr40/Ar36': '07:uncor. Ar40/Ar36', 'Ar40': '08:Ar40', 'Ar39': '09:Ar39', 'Ar38': '10:Ar38', 'Ar37': '11:Ar37', 'Ar36': '12:Ar36', 'j': '13:J' }
class LoadingManager(DVCIrradiationable): _pdf_writer = Instance(LoadingPDFWriter, ()) dirty = Bool(False) username = Str available_user_names = List identifier = Str identifiers = List weight = Float note = Str nxtals = Int save_directory = Str ''' when a hole is selected npositions defines the number of total positions to apply the current information i.e identifier ''' npositions = Int(1) auto_increment = Bool(False) positions = List grouped_positions = Property(depends_on='positions') # table signal/events scroll_to_row = Int selected_positions = List display_load_name = Str load_name = Str loads = List canvas = Any add_button = Button delete_button = Button archive_button = Button new_load_name = Str tray = Str trays = List sample_info = Property(depends_on='identifier') sample = Str project = Str irradiation_hole = Int packet = Str material = Str retain_weight = Bool(False) retain_note = Bool(False) retain_nxtals = Bool(False) show_samples = Bool(False) show_identifiers = Bool(False) show_weights = Bool(False) show_hole_numbers = Bool(False) show_nxtals = Bool(False) cmap_name = Enum(sorted(list(color_map_name_dict.keys()))) use_cmap = Bool(True) interaction_mode = Enum('Entry', 'Info', 'Edit') suppress_update = False use_measured = Bool(False) _suppress_edit = Bool(False) def __init__(self, *args, **kw): super(LoadingManager, self).__init__(*args, **kw) self.dvc.create_session() def load(self): if self.canvas: self.canvas.editable = True self.clear() return True def clear(self): self.load_name = '' if self.canvas: self.canvas.clear_all() def get_selection(self): from pychron.loading.load_view_selection import LoadViewSelectionModel, LoadViewSelectionController self.setup() if self.loads: self.use_measured = True self.load_name = self.loads[-1] oeditable = self.canvas.editable self.canvas.editable = False lvsm = LoadViewSelectionModel(manager=self) lvc = LoadViewSelectionController(model=lvsm) info = open_view(lvc) self.canvas.editable = oeditable self.use_measured = False if info.result: return lvsm.selected_positions else: self.warning_dialog('No Loads available') def load_load_by_name(self, loadtable): self.canvas = self.make_canvas(loadtable) if isinstance(loadtable, str): loadtable = self.dvc.db.get_loadtable(loadtable) self.positions = [] if not loadtable: return pos = [] for ln, poss in groupby_key(loadtable.loaded_positions, 'identifier'): dbpos = self.dvc.db.get_identifier(ln) sample = '' project = '' material = '' if dbpos.sample: sample = dbpos.sample.name if dbpos.sample.project: project = dbpos.sample.project.name if dbpos.sample.material: material = dbpos.sample.material.name dblevel = dbpos.level irrad = dblevel.irradiation.name level = dblevel.name irradpos = dbpos.position for pi in poss: item = self.canvas.scene.get_item(str(pi.position)) if item: item.fill = True item.add_identifier_label(ln, visible=self.show_identifiers) item.add_sample_label(sample, visible=self.show_samples) oy = -10 if not (self.show_identifiers or self.show_samples) else -20 wt = '' if pi.weight is None else str(pi.weight) item.add_weight_label(wt, oy=oy, visible=self.show_weights) nxtals = '' if pi.nxtals is None else str(pi.nxtals) item.add_nxtals_label(nxtals, oy=oy, visible=self.show_nxtals) item.nxtals = pi.nxtals item.weight = pi.weight p = LoadPosition(identifier=ln, sample=sample, material=material, weight=pi.weight or 0.0, nxtals=pi.nxtals or 0, project=project, irradiation=irrad, level=level, irrad_position=int(irradpos), position=pi.position) pos.append(p) self.positions = pos self._set_group_colors() self.canvas.request_redraw() def make_canvas(self, new, editable=True): db = self.dvc.db lt = db.get_loadtable(new) c = self.canvas if not c: c = LoadingCanvas(view_x_range=(-2, 2), view_y_range=(-2, 2), bgcolor='lightgray', editable=editable) if lt and lt.holderName: self.tray = lt.holderName holes = self.dvc.get_load_holder_holes(lt.holderName) load_holder_canvas(c, holes, show_hole_numbers=self.show_hole_numbers) for pi in lt.loaded_positions: item = c.scene.get_item(str(pi.position)) if item: item.fill = True item.identifier = pi.identifier item.add_identifier_label(item.identifier) item.add_sample_label(item.sample) for pi in lt.measured_positions: item = c.scene.get_item(str(pi.position)) if item: if pi.is_degas: item.degas_indicator = True else: item.measured_indicator = True self._set_group_colors(c) return c def setup(self): db = self.dvc.db if db.connected: ls = self._get_load_names() if ls: self.loads = ls ts = self.dvc.get_load_holders() self.debug('Found load holders={}'.format(ts)) if ts: ts = self._check_load_holders(ts) self.debug('Valid load holders={}'.format(ts)) self.trays = ts us = db.get_usernames() if us: self.available_user_names = us return True # actions # def generate_results(self): # self.debug('generate results') # dvc = self.dvc # db = dvc.db # # positions = sorted([pp for p in self.positions # for pp in p.positions]) # # wb = Workbook() # sh = wb.add_sheet('Results') # # for i, attr in enumerate(('Analysis', 'Position', 'Age', # 'Error', 'Weight', 'Note')): # wb.sheet(0, i, attr) # # wb.nrows = 1 # # def func(x, prog, i, n): # dbmps = db.get_measured_positions(self.load_name, x) # dbpos = db.get_load_position(self.load_name, x) # # weight, note = dbpos.weight, dbpos.note # # for dbmp in dbmps: # rid = dbmp.analysis.record_id # # rid = 1 # if prog: # prog.change_message('Write results for {},{}'.format(rid, x)) # # # ai = dvc.make_analyses((rid,)) # age, error = 0, 0 # # sh.write(wb.nrows, 0, rid) # sh.write(wb.nrows, 1, x) # sh.write(wb.nrows, 2, age) # sh.write(wb.nrows, 3, error) # sh.write(wb.nrows, 4, weight) # sh.write(wb.nrows, 5, note) # wb.nrows += 1 # # progress_iterator(positions, func, threshold=1) # # path, _ = unique_path(paths.load_results_dir, self.load_name, extension='.xls') # wb.save(path) def configure_pdf(self): options = self._pdf_writer.options options.orientation = 'portrait' options.left_margin = 0.5 options.right_margin = 0.5 options.top_margin = 0.5 options.bottom_margin = 0.5 options.load() info = options.edit_traits() if info.result: options.dump() def save_pdf(self): self.debug('save pdf') # p = LoadingPDFWriter() ln = self.load_name if ln: root = self.save_directory if not root or not os.path.isdir(root): root = paths.loading_dir ps = ', '.join({p.project for p in self.grouped_positions}) un = self.username dt = datetime.now() date_str = dt.strftime("%Y-%m-%d %H:%M:%S") meta = dict(load_name=ln, username=un, load_date=date_str, projects=ps) path = os.path.join(root, '{}.pdf'.format(ln)) options = self._pdf_writer.options osl = self.show_identifiers osw = self.show_weights oshn = self.show_hole_numbers oss = self.show_samples for attr in ('identifiers', 'weights', 'hole_numbers', 'samples'): attr = 'show_{}'.format(attr) setattr(self, attr, getattr(options, attr)) # c = self.canvas.clone_traits() self._pdf_writer.build(path, self.positions, self.grouped_positions, self.canvas, meta) if options.view_pdf: view_file(path) on = self.load_name self.canvas = None self.load_name = '' self.load_name = on self.show_identifiers = osl self.show_weights = osw self.show_hole_numbers = oshn self.show_samples = oss else: self.information_dialog('Please select a load') def save_tray_pdf(self): p = os.path.join(paths.loading_dir, self.tray) gc = PdfPlotGraphicsContext(filename=p) gc.render_component(self.canvas) gc.save() def save(self, save_positions=True, inform=False): self.debug('saving load to database') self._save_load() if save_positions: self._save_positions(self.load_name) self.dirty = False if inform: msg = 'Saved {} to database'.format(self.load_name) self.information_dialog(msg) return True # def set_edit(self): # if self.canvas: # self.canvas.event_state = 'edit' # self.interaction_mode = 'Edit' # # def set_entry(self): # # if self.canvas: # self.canvas.event_state = 'normal' # self.interaction_mode = 'Entry' # # def set_info(self): # # if self.canvas: # self.canvas.event_state = 'info' # self.interaction_mode = 'Info' # private def _check_load_holders(self, ts): ns = [] for ti in ts: try: self.dvc.get_load_holder_holes(ti) ns.append(ti) except MetaObjectException as e: self.warning(e) except BaseException: self.warning_dialog( '"{}" is an invalid load holder file. ' 'Holder unavailable until its fixed'.format(ti)) return ns def _get_load_names(self): loads = self.dvc.db.get_load_names() if loads is None: loads = [] return loads def _get_last_load(self): lt = self.dvc.db.get_loadtable() if lt: self.load_name = lt.name return self.load_name def _set_canvas_hole_selected(self, item): item.fill = True item.add_identifier_label(self.identifier, visible=self.show_identifiers, oy=-10) item.add_sample_label(self.sample, visible=self.show_samples, oy=-10) oy = -10 if not (self.show_identifiers or self.show_samples) else -20 item.add_weight_label(str(self.weight), visible=self.show_weights, oy=oy) item.add_nxtals_label(str(self.nxtals), visible=self.show_nxtals, oy=oy) item.weight = self.weight item.nxtals = self.nxtals item.note = self.note item.sample = self.sample item.irradiation = '{} {}{}'.format(self.irradiation, self.level, self.irradiation_hole) def _deselect_position(self, canvas_hole): # remove from position list pid = int(canvas_hole.name) p = next((p for p in self.positions if p.position == pid), None) if p is not None: self.positions.remove(p) # clear fill canvas_hole.fill = False canvas_hole.clear_text() def _new_position(self, canvas_hole): pid = int(canvas_hole.name) lp = LoadPosition(identifier=self.identifier, irradiation=self.irradiation, level=self.level, irrad_position=int(self.irradiation_hole), sample=self.sample, material=self.material, project=self.project, position=pid, nxtals=self.nxtals, weight=self.weight, note=self.note) self.positions.append(lp) self._set_canvas_hole_selected(canvas_hole) def _auto_increment_identifier(self): if self.auto_increment and self.identifier: idx = self.identifiers.index(self.identifier) try: self.identifier = self.identifiers[idx + 1] except IndexError: idx = self.levels.index(self.level) try: self.level = self.levels[idx + 1] self.identifier = self.identifiers[0] self.debug('increment level {}'.format(self.level)) except IndexError: idx = self.irradiations.index(self.irradiation) try: self.irradiation = self.irradiations[idx + 1] self.level = self.levels[0] self.identifier = self.identifiers[0] except IndexError: print('lm autoincrement', self.level, self.levels, self.level in self.levels, self.identifier) def _save_load(self): db = self.dvc.db nln = self.new_load_name if not self.username: self.warning_dialog('Please select a User') return if nln: self.info('adding load {} {} to database'.format(nln, self.tray)) db.add_load(nln, holder=self.tray, username=self.username) db.flush() ls = self._get_load_names() self.loads = ls self._get_last_load() self.new_load_name = '' def _save_positions(self, name): db = self.dvc.db lt = db.get_loadtable(name=name) for li in lt.loaded_positions: db.delete(li) for pp in self.positions: ln = pp.identifier self.info('updating positions for load:{}, identifier: {}'.format( lt.name, ln)) self.debug('weight: {} note: {}'.format(pp.weight, pp.note)) i = db.add_load_position(ln, position=pp.position, weight=pp.weight, note=pp.note, nxtals=pp.nxtals) lt.loaded_positions.append(i) db.commit() def _new_load_view(self): v = okcancel_view(Item('new_load_name', label='Name'), Item('tray', editor=EnumEditor(name='trays')), title='New Load Name', width=300) return v def _refresh_loads(self): self.loads = self._get_load_names() self.load_name = self.loads[0] def _set_group_colors(self, canvas=None): if canvas is None: canvas = self.canvas cs = {} if self.use_cmap: c = next( (k for k, v in color_map_dict.items() if v == self.cmap_name), None) if c: c = c(DataRange1D(low=0.0, high=1.0)) lns = sorted(list({p.identifier for p in self.positions})) nl = len(lns) scene = canvas.scene vs = c.map_screen(linspace(0, 1, nl)) cs = dict(zip(lns, [list(vi[:-1]) for vi in vs])) for i, p in enumerate(self.positions): color = cs.get(p.identifier, (1, 1, 0)) fcolor = ','.join([str(int(x * 255)) for x in color]) p.color = color # for pp in p.positions: pp = scene.get_item(p.position, klass=LoadIndicator) if pp is not None: pp.fill_color = fcolor @cached_property def _get_grouped_positions(self): gs = [] for idn, poss in groupby_key(self.positions, 'identifier'): poss = list(poss) gp = GroupedPosition(identifier=idn, meta_position=poss[0], positions=poss) gs.append(gp) return gs def _get_sample_info(self): return '{} {}{} {}'.format(self.identifier, self.level, self.irradiation_hole, self.sample) # ========================================================================== # handlers # ========================================================================== @on_trait_change('level') def _get_identifiers(self): db = self.dvc.db r = [] if db.connected: level = db.get_irradiation_level(self.irradiation, self.level) if level: r = sorted([ str(li.identifier) for li in level.positions if li.identifier ]) if r: self.identifier = r[0] self.identifiers = r def _identifier_changed(self, new): if self.dvc.db.connected and new: pos = self.dvc.db.get_identifier(new) self.irradiation_hole = pos.position self.packet = pos.packet or '' try: dbsample = pos.sample if dbsample: self.sample = dbsample.name if dbsample.material: self.material = dbsample.material.name if dbsample.project: self.project = dbsample.project.name except AttributeError: pass else: self.sample = '' self.packet = '' self.material = '' self.project = '' self.irradiation_hole = 0 def _archive_button_fired(self): ls = LoadSelection(loads=self.loads) info = ls.edit_traits() if info.result: db = self.dvc.db loads = db.get_load_names(names=ls.selected) for li in loads: li.archived = True db.commit() self.loads = self._get_load_names() def _add_button_fired(self): db = self.dvc.db ln = db.get_latest_load() try: ln = ln.name nv = int(ln) + 1 except (ValueError, IndexError, AttributeError) as e: print('lm add button exception', e) nv = 1 self.new_load_name = str(nv) info = self.edit_traits(view='_new_load_view') if info.result: self.save(save_positions=False) self._refresh_loads() def _delete_button_fired(self): ln = self.load_name if ln: if not self.confirmation_dialog( 'Are you sure you want to delete {}?'.format(ln)): return db = self.dvc.db # delete the load and any associated records dbload = db.get_loadtable(name=ln) if dbload: for ps in (dbload.loaded_positions, dbload.measured_positions): for pos in ps: db.delete(pos) db.delete(dbload) db.commit() self._refresh_loads() @on_trait_change('load_name') def _fetch_load(self): if self.load_name: self.tray = '' self.load_load_by_name(self.load_name) self.display_load_name = self.load_name def _show_samples_changed(self, new): if self.canvas: for lp in self.positions: item = self.canvas.scene.get_item(str(lp.position)) item.sample_label.visible = new item.weight_label.oy = -20 if new else -10 item.nxtals_label.oy = -20 if new else -10 item.sample_label.request_layout() self.canvas.request_redraw() def _show_identifiers_changed(self, new): if self.canvas: for lp in self.positions: item = self.canvas.scene.get_item(str(lp.position)) item.identifier_label.visible = new item.weight_label.oy = -20 if new else -10 item.nxtals_label.oy = -20 if new else -10 item.identifier_label.request_layout() self.canvas.request_redraw() def _show_weights_changed(self, new): if self.canvas: for lp in self.positions: item = self.canvas.scene.get_item(str(lp.position)) item.weight_label.visible = new item.weight_label.request_layout() self.canvas.request_redraw() def _show_hole_numbers_changed(self, new): if self.canvas: for item in self.canvas.scene.get_items(LoadIndicator): item.name_visible = new self.canvas.request_redraw() def _show_nxtals_changed(self, new): if self.canvas: for lp in self.positions: item = self.canvas.scene.get_item(str(lp.position)) item.nxtals_label.visible = new item.nxtals_label.request_layout() self.canvas.request_redraw() def _cmap_name_changed(self): self._set_group_colors() self.canvas.request_redraw() self.refresh_table = True def _note_changed(self): if self.canvas: sel = self.canvas.selected if sel: sel.note = self.note # pos = next((p for p in self.positions if int(sel.name) in p.positions)) # pos.note = self.note def _weight_changed(self): if self._suppress_edit: return if self.canvas: sel = self.canvas.selected if sel: sel.weight = self.weight sel.weight_label.text = self.weight def _nxtals_changed(self): if self._suppress_edit: return if self.canvas: sel = self.canvas.selected if sel: sel.nxtals = self.nxtals sel.nxtals_label.text = self.nxtals @on_trait_change('canvas:selected') def _update_selected(self, new): if not new: return if not self.load_name: self.warning_dialog('Select a load') return if not self.canvas.editable: if self.use_measured: if new.measured_indicator: p = next((p for p in self.selected_positions if int(new.name) in p.positions), None) if p: self.selected_positions.remove(p) else: self.selected_positions.append( LoadPosition(positions=[int(new.name)], identifier=new.identifier)) else: pp = [] ps = self.canvas.get_selection() for p in ps: po = next((ppp for ppp in self.positions if int(p.name) in ppp.positions), None) if po: pp.append(po) self.selected_positions = pp return if not self.username: self.warning_dialog('Set a username') return if self.canvas.event_state in ('edit', 'info'): self.note = new.note self.weight = new.weight or 0 else: if new.fill: self._deselect_position(new) else: if not self.identifier: self.warning_dialog('Select a Labnumber') else: for i in range(self.npositions): if not new: continue item = self.canvas.scene.get_item(new.name) if item.fill: continue self._new_position(new) new = self.canvas.scene.get_item( str(int(new.name) + 1)) if new: self.canvas.set_last_position(int(new.name)) self._suppress_edit = True if not self.retain_weight: self.weight = 0 if not self.retain_note: self.note = '' if not self.retain_nxtals: self.nxtals = 0 self._suppress_edit = False self._auto_increment_identifier() # self._update_span_indicators() self._set_group_colors() # self.refresh_table = True self.dirty = True self.canvas.request_redraw()
LIGHT_YELLOW = color_table["lightyellow"] DARK_RED = color_table["darkred"] VIOLET = color_table["violet"] WHITE = color_table["white"] # Color palettes supported in Matplotlib: # Remove jet since seaborn doesn't support it: ALL_MPL_PALETTES = sorted(mpl_cm.cmap_d.keys()) ALL_MPL_PALETTES.remove("jet") # Color palettes supported in Chaco: ALL_CHACO_PALETTES = sorted(color_map_name_dict.keys()) ALL_CHACO_COLORS = sorted(color_table.keys()) BASIC_COLORS = [ BLUE, RED, BLACK, GREEN, PURPLE, ORANGE, YELLOW, MAGENTA, AQUA, PINK, BROWN, LIGHT_GRAY, DARK_GRAY, TAN, LIGHT_BLUE, LIGHT_GREEN, LIGHT_YELLOW, DARK_RED, WHITE ] def generate_chaco_colors(n_colors, palette="hsv"): """ Generate distant color codes for Chaco/enable. Parameters ----------
def __init__(self, *args, **kw): super(ContourPolyPlotEditor, self).__init__(*args, **kw) self.cmap_names = color_map_name_dict.keys()