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):
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()
