def export_images(self):
# TODO: use time/index stepping
standard, ok = QtGui.QInputDialog.getItem(self,
_('Choose standard to show'),
_('Standard'),
standards)
if not ok:
return
output_filename = QtGui.QFileDialog.getSaveFileName(self,
'Save Report',
'',
'*.html')
if not output_filename:
return
instrument_name = self.decoder.datapath.split('/')[1]
sample_name = self.decoder.datapath.split('/')[2]
instrument = getattr(self.decoder.proxy.conf, instrument_name)
sample = getattr(instrument, sample_name)
characteristic_shapes = get_shapes(sample, standard)
output_html = htmlreport.create_images_report(
self.decoder,
instrument.measure,
self.doc.data['0:t'].data,
self.doc.data.get('0:kiln/T').data,
characteristic_shapes,
standard=standard
)
with open(output_filename, 'w') as output_file:
output_file.write(output_html)
def __init__(self, parent, name=None):
veusz.widgets.BoxShape.__init__(self, parent, name=name)
if type(self) == DataPoint:
self.readDefaults()
self.addAction(
veusz.widgets.widget.Action('up',
self.actionUp,
descr='Update Data Point',
usertext='Update Data Point'))
self.addAction(
veusz.widgets.widget.Action('removeGaps',
self.removeGaps,
descr='Remove Gaps',
usertext='Remove Gaps'))
self.settings.Fill.add(
setting.Bool(
'extended_clicakble_area',
True,
descr=
_('If enabled, datapoint is easier to select, but can create problems when printing.'
),
usertext=_('Extend clickable area')))
def up(self):
logging.debug('DATABASEWIDGET UP')
self.table.model().up()
header = self.table.model().header
sh = self.table.model().sheader
hh = self.table.horizontalHeader()
self.qfilter.clear()
self.qfilter.addItem(_('All'), '*')
for i, h in enumerate(header):
logging.debug('qfilter', i, h)
if hh.isSectionHidden(i):
continue
self.qfilter.addItem(_(sh[i]), h)
self.table.horizontalHeader().moveSection(name_column, 0)
self.table.horizontalHeader().moveSection(incremental_id_column, 1)
self.table.horizontalHeader().moveSection(serial_column, 2)
self.table.horizontalHeader().hideSection(id_column)
self.table.horizontalHeader().hideSection(uid_column)
self.table.horizontalHeader().hideSection(verify_column)
self.table.horizontalHeader().hideSection(file_column)
self.table.horizontalHeader().hideSection(flavour_column)
self.table.resizeColumnToContents(name_column)
def up(self):
logging.debug('DATABASEWIDGET UP')
self.table.model().up()
header = self.table.model().header
sh = self.table.model().sheader
hh = self.table.horizontalHeader()
self.qfilter.clear()
self.qfilter.addItem(_('All'), '*')
for i, h in enumerate(header):
logging.debug('qfilter', i, h)
if hh.isSectionHidden(i):
continue
self.qfilter.addItem(_(sh[i]), h)
self.table.horizontalHeader().moveSection(name_column, 0)
self.table.horizontalHeader().moveSection(incremental_id_column, 1)
self.table.horizontalHeader().moveSection(serial_column, 2)
self.table.horizontalHeader().hideSection(id_column)
self.table.horizontalHeader().hideSection(uid_column)
self.table.horizontalHeader().hideSection(verify_column)
self.table.horizontalHeader().hideSection(file_column)
self.table.horizontalHeader().hideSection(flavour_column)
self.table.resizeColumnToContents(name_column)
def __init__(self, remote=False, parent=None, browser=False):
QtGui.QTableView.__init__(self, parent)
self.remote = remote
self.browser = browser
self.curveModel = DatabaseModel(remote)
self.setModel(self.curveModel)
self.selection = QtGui.QItemSelectionModel(self.model())
self.setSelectionModel(self.selection)
self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.setEditTriggers(QtGui.QAbstractItemView.EditKeyPressed)
self.connect(
self, QtCore.SIGNAL('doubleClicked(QModelIndex)'), self.select)
self.setHorizontalHeader(DatabaseHeader(parent=self))
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(
self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'), self.showMenu)
self.menu.addAction(
_('Open selected tests'), lambda: self.select(None))
if self.browser:
self.menu_add_to = self.menu.addMenu(_('Add to...'))
self.menu.addAction(_('View folder'), self.view_folder)
self.menu.addAction(_('Delete'), self.delete)
def export_images_option_dialog(parent, max_temp):
opts = {}
option.ao(opts,
'standard',
'Chooser',
standards[0],
name=_("Standard for characteristic shapes"),
options=standards)
option.ao(opts,
'start',
'Integer',
name=_("Discard images below temperature"),
unit='celsius',
current=0,
min=0,
max=max_temp + 1,
step=1)
option.ao(opts,
'step',
'Float',
name=_("Temperature stepping"),
unit='celsius',
current=1,
min=0,
max=50,
step=0.1)
configuration_proxy = option.ConfigurationProxy({'self': opts})
temperature_dialog = conf.InterfaceDialog(configuration_proxy,
configuration_proxy,
opts,
parent=parent)
temperature_dialog.setWindowTitle(_('Image export options'))
if temperature_dialog.exec_():
return configuration_proxy
return False
def __init__(self, remote=False, parent=None, browser=False):
QtGui.QTableView.__init__(self, parent)
self.remote = remote
self.browser = browser
self.curveModel = DatabaseModel(remote)
self.setModel(self.curveModel)
self.selection = QtGui.QItemSelectionModel(self.model())
self.setSelectionModel(self.selection)
self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.setEditTriggers(QtGui.QAbstractItemView.EditKeyPressed)
self.connect(self, QtCore.SIGNAL('doubleClicked(QModelIndex)'),
self.select)
self.setHorizontalHeader(DatabaseHeader(parent=self))
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.showMenu)
self.menu.addAction(_('Open selected tests'),
lambda: self.select(None))
if self.browser:
self.menu_add_to = self.menu.addMenu(_('Add to...'))
self.menu.addAction(_('View folder'), self.view_folder)
self.menu.addAction(_('Delete'), self.delete)
def chStyle(self):
w = self.decoder.contour_width
c = self.decoder.contour_only
dia = QtGui.QDialog()
lay = QtGui.QFormLayout()
#w = QtGui.QWidget()
#w.setLayout(lay)
wg_only = QtGui.QCheckBox()
wg_only.setChecked(c)
wg_width = QtGui.QSpinBox()
wg_width.setRange(0, 100)
wg_width.setValue(w)
wg_closed = QtGui.QCheckBox()
wg_closed.setChecked(self.decoder.contour_closed)
ok = QtGui.QPushButton(_("Ok"))
canc = QtGui.QPushButton(_("Cancel"))
lay.addRow(_("Contour only: "), wg_only)
lay.addRow(_("Contour width: "), wg_width)
lay.addRow(_("Draw sample holder: "), wg_closed)
lay.addRow(canc, ok)
ok.pressed.connect(dia.accept)
canc.pressed.connect(dia.reject)
dia.setLayout(lay)
r = dia.exec_()
if r == QtGui.QDialog.Rejected:
return False
self.decoder.contour_only = bool(wg_only.checkState())
self.decoder.contour_width = wg_width.value()
self.decoder.contour_closed = bool(wg_closed.checkState())
self.decoder.cached_profiles = {}
return True
def __init__(self, addr, user='******', password='******', mac='', globalconn=True, parent=None, context='Local'):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle('Login Required')
self.lay = QtGui.QGridLayout(self)
self.setLayout(self.lay)
self.addr = addr
self.mac = mac
self.userLbl = QtGui.QLabel(_('User Name') + ':')
self.pwdLbl = QtGui.QLabel(_('Password') + ':')
self.user = QtGui.QLineEdit(user)
self.password = QtGui.QLineEdit(password)
self.ckSave = QtGui.QCheckBox(_('Save login'), self)
from misura.client import iutils
self.ckSave.setCheckState(2 * confdb['saveLogin'])
self.ok = QtGui.QPushButton('Ok')
self.ko = QtGui.QPushButton(_('Cancel'))
self.connect(self.ok, QtCore.SIGNAL('clicked()'), self.tryLogin)
self.connect(self.ko, QtCore.SIGNAL('clicked()'), self.reject)
self.lay.addWidget(QtGui.QLabel('Destination:'), 1, 0)
self.lay.addWidget(QtGui.QLabel(self.addr), 1, 1)
self.lay.addWidget(self.userLbl, 2, 0)
self.lay.addWidget(self.user, 2, 1)
self.lay.addWidget(self.pwdLbl, 3, 0)
self.lay.addWidget(self.password, 3, 1)
self.lay.addWidget(self.ok, 4, 0)
self.lay.addWidget(self.ko, 4, 1)
self.lay.addWidget(self.ckSave, 5, 1)
self.obj = False
if globalconn:
self.fConnect = network.getConnection
else:
self.fConnect = network.simpleConnection
self.user.setFocus()
def chStyle(self):
w = self.decoder.contour_width
c = self.decoder.contour_only
dia = QtGui.QDialog()
lay = QtGui.QFormLayout()
#w = QtGui.QWidget()
#w.setLayout(lay)
wg_only = QtGui.QCheckBox()
wg_only.setChecked(c)
wg_width = QtGui.QSpinBox()
wg_width.setRange(0, 100)
wg_width.setValue(w)
ok = QtGui.QPushButton(_("Ok"))
canc = QtGui.QPushButton(_("Cancel"))
lay.addRow(_("Contour only: "), wg_only)
lay.addRow(_("Contour width: "), wg_width)
lay.addRow(canc, ok)
ok.pressed.connect(dia.accept)
canc.pressed.connect(dia.reject)
dia.setLayout(lay)
r = dia.exec_()
if r == QtGui.QDialog.Rejected:
return False
self.decoder.contour_only = wg_only.checkState()
self.decoder.contour_width = wg_width.value()
self.decoder.cached_profiles = {}
return True
def update_page_image(self, page=False):
# initialize cache
if not page:
page = self.page
if not page:
logging.debug('No page')
return False
if page not in self.doc.basewidget.children:
logging.debug('PAGE DOES NOT EXISTS', page.name)
return False
if page.name in self.cache:
lbl, changeset = self.cache[page.name]
if changeset >= self.doc.changeset:
logging.debug('Not updating page', changeset,
self.doc.changeset)
return False
pageNum = self.doc.basewidget.children.index(page)
fp = self.fpath(page)
logging.debug('writing page to', fp)
export = document.Export(
self.doc,
fp,
pageNum,
)
export.export()
# Build the label
if page.name not in self.cache:
lbl = QtGui.QToolButton(parent=self.container)
lbl.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
lbl.setStyleSheet("QToolButton { font: 12px}")
show_func = functools.partial(self.slot_select_page, page.name)
list_children_func = functools.partial(self.slot_list_children,
page.name)
del_func = functools.partial(self.slot_delete_page, page.name)
export_func = functools.partial(self.slot_export_page, pageNum)
lbl.clicked.connect(show_func)
menu = QtGui.QMenu()
menu.addAction(_('Show'), show_func)
menu.addAction(_('List children'), list_children_func)
menu.addAction(_('Delete'), del_func)
menu.addAction(_('Export'), export_func)
lbl.setMenu(menu)
else:
lbl, changeset = self.cache[page.name]
# Replace the icon
logging.debug('loading page from', fp)
icon = QtGui.QIcon(fp)
lbl.setIcon(icon)
size = QtCore.QSize(200, 100)
pix = icon.pixmap(size)
lbl.setIconSize(pix.size())
self.cache[page.name] = lbl, self.doc.changeset
return True
def __init__(self, n=5, parent=None):
QtGui.QWidget.__init__(self, parent)
self._extrusion = []
self.lay = QtGui.QGridLayout()
self.setLayout(self.lay)
self.n = n
self.labels = []
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.showMenu)
self.menu.addAction(_('Change length'), self.chLen)
self.menu.addAction(_('Change rows'), self.chRows)
self.menu.addAction(_('Style'), self.chStyle)
self.uniform_zoom = self.menu.addAction(_('Uniform zoom'),
self.slot_zoom_changed)
self.uniform_zoom.setCheckable(True)
self.uniform_zoom.setChecked(True)
self.actIndex = self.menu.addAction(_('Step by index'), self.by_index)
self.actIndex.setCheckable(True)
self.actTime = self.menu.addAction(_('Step by time'), self.by_time)
self.actTime.setCheckable(True)
self.menu.addAction(_("Export Images"), self.export_images)
from misura.client import video, extrusion
if video.cv:
self.menu.addAction(_("Render video"), self.render_video)
if extrusion.pg:
self.menu.addAction(_("3D Extrusion"), self.render_extrusion)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self._lock = threading.Lock()
self.lay = QtGui.QHBoxLayout()
self.setLayout(self.lay)
self.setWindowTitle(_('Local Operations in Progress'))
# Base widget
self.bw = QtGui.QWidget(parent=self)
self.blay = QtGui.QVBoxLayout()
self.bw.setLayout(self.blay)
self.log = QtGui.QTextEdit(parent=self)
self.log.setReadOnly(True)
self.log.setLineWrapMode(self.log.NoWrap)
self.log.setFont(QtGui.QFont('TypeWriter', 7, 50, False))
self.log.hide()
self.more = QtGui.QPushButton(_('Log'), parent=self)
self.connect(self.more, QtCore.SIGNAL('clicked()'), self.toggle_log)
# Progress bars widget
self.mw = QtGui.QWidget(parent=self)
self.mlay = QtGui.QVBoxLayout()
self.mw.setLayout(self.mlay)
# Populate the base widget with progress widget, more button, log
# window
self.blay.addWidget(self.mw)
self.blay.addWidget(self.more)
self.blay.addWidget(self.log)
self.lay.addWidget(self.bw)
self.prog = {}
conntype = QtCore.Qt.UniqueConnection
self.connect(self, QtCore.SIGNAL('jobs(int)'),
self._jobs, conntype)
self.connect(self, QtCore.SIGNAL('jobs(int,QString,PyQt_PyObject)'),
self._jobs, conntype)
self.connect(self, QtCore.SIGNAL('job(int,QString,QString)'),
self._job, conntype)
self.connect(self, QtCore.SIGNAL('job(int,QString)'),
self._job, conntype)
self.connect(self, QtCore.SIGNAL('job(int)'),
self._job, conntype)
self.connect(self, QtCore.SIGNAL('sig_done(QString)'),
self._done,conntype)
self.connect(self, QtCore.SIGNAL('sig_done0()'),
self._done, conntype)
logging.debug( 'LocalTasks initialized')
self.log_messages = ''
def __init__(self,
doc,
datapath=False,
curWidth=100,
maxWidth=600,
minWidth=15,
slider=False,
parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.lay = QtGui.QVBoxLayout()
self.lay.setContentsMargins(0, 0, 0, 0)
self.lay.setSpacing(0)
self.setLayout(self.lay)
self.setAcceptDrops(True)
# Proper image label
self.lbl_img = QtGui.QLabel(parent=self)
self.lbl_img.setPixmap(QtGui.QPixmap())
self.lay.addWidget(self.lbl_img)
# Optional Metadata label
self.lbl_info = QtGui.QLabel(parent=self)
self.lay.addWidget(self.lbl_info)
self.lbl_info.hide()
self.meta = {'T': None}
self.doc = doc
logging.debug('datapath', datapath)
self.decoder = doc.decoders.get(datapath, False)
self.img = QtGui.QImage()
self.curWidth = curWidth
self.defaultWidth = curWidth
self.maxWidth = maxWidth
self.minWidth = minWidth
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.showMenu)
self.menu.addAction(_('Next'), self.next)
self.menu.addAction(_('Previous'), self.prev)
self.menu.addAction(_('Save'), self.save_frame)
self.menu.addAction(_('To Clipboard'), self.copy_to_clipboard)
self.meta_menu = self.menu.addMenu(_('Labels'))
# Slider for image navigation
self.slider = QtGui.QScrollBar(parent=self)
if self.decoder:
self.slider.setMaximum(len(self.decoder))
self.slider.setMinimum(0)
self.slider.setTracking(False)
self.slider.setOrientation(QtCore.Qt.Horizontal)
self.slider.valueChanged.connect(self.set_idx)
if not slider:
self.slider.hide()
if self.decoder:
self.connect(self.decoder, QtCore.SIGNAL('cached(int)'),
self.cached)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self._lock = threading.Lock()
self.lay = QtGui.QHBoxLayout()
self.setLayout(self.lay)
self.setWindowTitle(_('Local Operations in Progress'))
# Base widget
self.bw = QtGui.QWidget(parent=self)
self.blay = QtGui.QVBoxLayout()
self.bw.setLayout(self.blay)
self.log = QtGui.QTextEdit(parent=self)
self.log.setReadOnly(True)
self.log.setLineWrapMode(self.log.NoWrap)
self.log.setFont(QtGui.QFont('TypeWriter', 7, 50, False))
self.log.hide()
self.more = QtGui.QPushButton(_('Log'), parent=self)
self.connect(self.more, QtCore.SIGNAL('clicked()'), self.toggle_log)
# Progress bars widget
self.mw = QtGui.QWidget(parent=self)
self.mlay = QtGui.QVBoxLayout()
self.mw.setLayout(self.mlay)
# Populate the base widget with progress widget, more button, log
# window
self.blay.addWidget(self.mw)
self.blay.addWidget(self.more)
self.blay.addWidget(self.log)
self.lay.addWidget(self.bw)
self.prog = {}
conntype = QtCore.Qt.UniqueConnection
self.connect(self, QtCore.SIGNAL('jobs(int)'), self._jobs, conntype)
self.connect(self, QtCore.SIGNAL('jobs(int,QString,PyQt_PyObject)'),
self._jobs, conntype)
self.connect(self, QtCore.SIGNAL('job(int,QString,QString)'),
self._job, conntype)
self.connect(self, QtCore.SIGNAL('job(int,QString)'), self._job,
conntype)
self.connect(self, QtCore.SIGNAL('job(int)'), self._job, conntype)
self.connect(self, QtCore.SIGNAL('sig_done(QString)'), self._done,
conntype)
self.connect(self, QtCore.SIGNAL('sig_done0()'), self._done, conntype)
logging.debug('LocalTasks initialized')
self.log_messages = ''
def add_datasets(self, start_index, start_value):
"""Add standard and fitted datasets for further evaluations (plotting, etc)"""
# Adding plot data
fields = self.fld
name = fields['std'].replace(' ', '_')
p = fields['d'] + '/' + name
Tds = self.doc.data[fields['T']]
T = Tds.data
old_unit = getattr(self.ds, 'old_unit', 'percent')
# Fitting
# f=np.poly1d((self.slope,0))
f = np.poly1d((self.quad, self.slope, 0))
df = f(T)
df += start_value - df[start_index]
# TODO: define new derived datasets for these
dsf = copy(Tds)
dsf.attr = dict({}, **Tds.attr)
dsf.tags = set([])
dsf.data = plugins.numpyCopyOrNone(df)
dsf.m_var = name + '_fit'
dsf.m_pos = 2
dsf.m_name = dsf.m_var
dsf.m_col = dsf.m_var
dsf.old_unit = old_unit
dsf.unit = 'percent'
dsf.m_initialDimension = self.inidim
dsf.m_label = _('Calibration Fitting')
self.ops.append(
document.OperationDatasetSet(p + '_fit', dsf))
# Evaluate std fit over regular T
d = self.f(T)
# Translate zero so it matches the fit
d -= d[start_index] - df[start_index]
dsd = copy(Tds)
dsd.attr = dict({}, **Tds.attr)
dsd.tags = set([])
dsd.data = plugins.numpyCopyOrNone(d)
dsd.m_var = name
dsd.m_pos = 1
dsd.m_name = name
dsd.m_col = name
dsd.unit = 'percent'
dsd.old_unit = old_unit
dsd.m_initialDimension = self.inidim
dsd.m_label = _(name)
self.ops.append(
document.OperationDatasetSet(p, dsd))
def add_coord(name):
# TODO: replace with enc.role2dev('motor')
enc = getattr(self.remote.encoder, name)
m = enc['motor']
if m is False:
return False
logging.debug(m)
path = m[0]
if path in ('None', None):
return False
if self.server.searchPath(path) is False:
return False
obj = self.server.toPath(path)
if obj is None:
return False
submenu = menu.addMenu(_(name.capitalize()))
act = widgets.MotorSliderAction(self.server, obj, submenu)
submenu.addAction(act)
align=enc['align']
if name == 'y' or (name == 'x' and not self.instrument_is_flex()):
slider = widgets.MotorSlider(
self.server, obj, parent=self.parent)
slider.spinbox.hide()
self.parent.setControl(slider, cpos[name])
self.motor_ctrl[name] = slider
act = widgets.aBooleanAction(
obj, obj.gete('moving'), parent=submenu)
submenu.addAction(act)
self.button_action(
'limits', label='Search limits', obj=obj, menu=submenu)
self.button_action(
'zero', label='Set zero position', obj=obj, menu=submenu)
self.add_conf_action(submenu, obj, path, txt='Configure motor')
self.add_conf_action(submenu, enc, txt='Configure encoder')
def export(self):
"""Start export thread"""
self.btn_ko.setEnabled(True)
prog = QtGui.QProgressBar()
self.lay.addRow(_('Rendering:'), prog)
src = str(self.cfg['src'])
ext = str(self.cfg['ext'])
if 'frm' in self.cfg:
frm = str(self.cfg['frm'])
fourcc = cv.VideoWriter_fourcc(*frm)
else:
fourcc = default_fourcc
out = str(self.out.text())
self.prog = prog
export(self.sh,
frame=src + '/' + ext,
T=self.cfg['T'],
fourcc=fourcc,
output=out,
framerate=self.cfg['fps'],
prog=prog,
acquisition_start_temperature=self.cfg['startTemp'],
Tstep=self.cfg['Tstep'],
tstep=self.cfg['tstep'],
centerx=self.cfg['centerx'],
centery=self.cfg['centery'])
self.done(0)
def get_delete_selection(table_view):
records = []
for record in iter_selected(table_view):
records.append(record)
n = min(len(records), 10)
N = len(records)
msg = '\n'.join([r[3] for r in records[:n]])
msg = _("You are going to delete {} files, including:").format(
N) + '\n' + msg
ok = QtGui.QMessageBox.question(table_view,
_("Permanently delete test data?"), msg,
QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel,
QtGui.QMessageBox.Cancel)
if ok != QtGui.QMessageBox.Ok:
logging.debug('Delete aborted')
return []
return records
def add_datasets(self, start_index, start_value):
"""Add standard and fitted datasets for further evaluations (plotting, etc)"""
# Adding plot data
fields = self.fld
name = fields['std'].replace(' ', '_')
p = fields['d'] + '/' + name
Tds = self.doc.data[fields['T']]
T = Tds.data
old_unit = getattr(self.ds, 'old_unit', 'percent')
# Fitting
# f=np.poly1d((self.slope,0))
f = np.poly1d((self.quad, self.slope, 0))
df = f(T)
df += start_value - df[start_index]
# TODO: define new derived datasets for these
dsf = copy(Tds)
dsf.attr = dict({}, **Tds.attr)
dsf.tags = set([])
dsf.data = plugins.numpyCopyOrNone(df)
dsf.m_var = name + '_fit'
dsf.m_pos = 2
dsf.m_name = dsf.m_var
dsf.m_col = dsf.m_var
dsf.old_unit = old_unit
dsf.unit = 'percent'
dsf.m_initialDimension = self.inidim
dsf.m_label = _('Calibration Fitting')
self.ops.append(document.OperationDatasetSet(p + '_fit', dsf))
# Evaluate std fit over regular T
d = self.f(T)
# Translate zero so it matches the fit
d -= d[start_index] - df[start_index]
dsd = copy(Tds)
dsd.attr = dict({}, **Tds.attr)
dsd.tags = set([])
dsd.data = plugins.numpyCopyOrNone(d)
dsd.m_var = name
dsd.m_pos = 1
dsd.m_name = name
dsd.m_col = name
dsd.unit = 'percent'
dsd.old_unit = old_unit
dsd.m_initialDimension = self.inidim
dsd.m_label = _(name)
self.ops.append(document.OperationDatasetSet(p, dsd))
def __init__(self, doc, datapath=False, curWidth=100, maxWidth=600, minWidth=100, slider=False, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.lay = QtGui.QVBoxLayout()
self.lay.setContentsMargins(0, 0, 0, 0)
self.lay.setSpacing(0)
self.setLayout(self.lay)
self.setAcceptDrops(True)
# Proper image label
self.lbl_img = QtGui.QLabel(parent=self)
self.lbl_img.setPixmap(QtGui.QPixmap())
self.lay.addWidget(self.lbl_img)
# Optional Metadata label
self.lbl_info = QtGui.QLabel(parent=self)
self.lay.addWidget(self.lbl_info)
self.lbl_info.hide()
self.meta = {'T': None}
self.doc = doc
logging.debug('datapath', datapath)
self.decoder = doc.decoders.get(datapath, False)
self.img = QtGui.QImage()
self.curWidth = curWidth
self.defaultWidth = curWidth
self.maxWidth = maxWidth
self.minWidth = minWidth
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(
self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'), self.showMenu)
self.menu.addAction(_('Next'), self.next)
self.menu.addAction(_('Previous'), self.prev)
self.menu.addAction(_('Save'), self.save_frame)
self.menu.addAction(_('To Clipboard'), self.copy_to_clipboard)
self.meta_menu = self.menu.addMenu(_('Labels'))
# Slider for image navigation
self.slider = QtGui.QScrollBar(parent=self)
if self.decoder:
self.slider.setMaximum(len(self.decoder))
self.slider.setMinimum(0)
self.slider.setTracking(False)
self.slider.setOrientation(QtCore.Qt.Horizontal)
self.slider.valueChanged.connect(self.set_idx)
if not slider:
self.slider.hide()
if self.decoder:
self.connect(
self.decoder, QtCore.SIGNAL('cached(int)'), self.cached)
def __init__(self, parent=None, context='Local'):
QtGui.QToolBox.__init__(self, parent)
self.connect(network.manager, QtCore.SIGNAL(
'found(QString)'), self.redraw, QtCore.Qt.QueuedConnection)
self.connect(network.manager, QtCore.SIGNAL(
'lost(QString)'), self.redraw, QtCore.Qt.QueuedConnection)
self.label = _('Server Selector')
self.redraw()
def get_delete_selection(table_view):
records = []
for record in iter_selected(table_view):
records.append(record)
n = min(len(records), 10)
N = len(records)
msg = '\n'.join([r[3] for r in records[:n]])
msg = _("You are going to delete {} files, including:").format(
N) + '\n' + msg
ok = QtGui.QMessageBox.question(
table_view, _("Permanently delete test data?"), msg,
QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel,
QtGui.QMessageBox.Cancel)
if ok != QtGui.QMessageBox.Ok:
logging.debug('Delete aborted')
return []
return records
def __init__(self, parent, name=None):
veusz.widgets.BoxShape.__init__(self, parent, name=name)
if type(self) == DataPoint:
self.readDefaults()
self.addAction(veusz.widgets.widget.Action('up', self.actionUp,
descr='Update Data Point',
usertext='Update Data Point'))
self.addAction(
veusz.widgets.widget.Action('removeGaps', self.removeGaps,
descr='Remove Gaps',
usertext='Remove Gaps'))
self.settings.Fill.add(setting.Bool('extended_clicakble_area', True,
descr = _('If enabled, datapoint is easier to select, but can create problems when printing.'),
usertext=_('Extend clickable area')) )
def __init__(self):
QtGui.QTabWidget.__init__(self)
self._lock = threading.Lock()
self.setWindowTitle(_('Pending Tasks'))
self.progress = RemoteTasks()
self.addTab(self.progress, _('Remote'))
self.tasks = LocalTasks()
self.addTab(self.tasks, _('Local'))
self.sync = SyncWidget(self)
self.addTab(self.sync, _('Storage'))
self.tasks.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
self.progress.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
self.sync.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
def __init__(self):
QtGui.QTabWidget.__init__(self)
self._lock = threading.Lock()
self.setWindowTitle(_('Pending Tasks'))
self.progress = RemoteTasks()
self.addTab(self.progress, _('Remote'))
self.tasks = LocalTasks()
self.addTab(self.tasks, _('Local'))
self.sync = SyncWidget(self)
self.addTab(self.sync, _('Storage'))
self.tasks.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
self.progress.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
self.sync.ch.connect(self.hide_show, QtCore.Qt.QueuedConnection)
def __init__(self,
d='',
T='',
std='NIST-SRM738',
start=50,
end=50,
label=True,
add=True):
"""Make list of fields."""
self.fields = [
plugins.FieldDataset("d", descr=_("Expansion dataset"), default=d),
plugins.FieldDataset("T",
descr=_("Temperature dataset"),
default=T),
plugins.FieldCombo("std",
descr=_("Calibraiton Standard"),
items=standards.keys(),
default=std),
plugins.FieldFloat('start',
descr=_('First temperature margin'),
default=start),
plugins.FieldFloat('end',
descr=_('Last temperature margin'),
default=end),
plugins.FieldBool('label',
_('Draw calibration label'),
default=label),
plugins.FieldBool('add',
_('Add calibration datasets'),
default=add),
]
def reconnectSample(self):
"""Remove and regenerate all samples."""
self.sampleProcessor.toggle_run(False)
stream = self.processor.stream
self.processor.toggle_run(False)
n = self.remote['nSamples']
for smp_pix in self.samples:
smp_pix.hide()
smp_pix.close()
self.gscene.removeItem(smp_pix)
del smp_pix
self.samples = []
samples = []
for i in range(n):
logging.debug('RECONNECTING SAMPLES', i, n, self.remote['fullpath'])
name = 'smp%i' % i
if not self.remote.has_key(name):
logging.debug('Sample not found', name)
continue
# Get the current analysis sample
path = self.remote[name][0]
if path in [None, 'None']:
logging.debug('No sample path defined', path)
continue
sample = self.server.toPath(path)
if sample is None:
logging.debug('Sample path not found', path)
continue
fp = sample['fullpath']
samples.append(sample)
smp_pix = SamplePicture(self.plane, sample, i)
smp_pix.roi.get()
# Show the roi only if option is checked
if self.roiAct.isChecked():
smp_pix.roi.show()
smp_pix.roi.grid.set_enabled(self.gridAct.isChecked())
self.samples.append(smp_pix)
# Menu structure for samples
m = self.menus.get(name, False)
if m is False:
m = self.menu.addMenu(_('Sample ') + str(i))
self.menus[name] = m
m.clear()
self.add_conf_action(m, sample, fp)
self.bool_action(
'Black/white levelling', 'blackWhite', sample.analyzer, m)
self.bool_action(
'Adaptive Threshold', 'adaptiveThreshold', sample.analyzer, m)
self.bool_action(
'Dynamic Regions', 'autoregion', sample.analyzer, m)
self.sampleProcessor.set_samples(samples)
self.sampleProcessor.toggle_run(do=stream)
self.processor.toggle_run(do=stream)
self.emit(QtCore.SIGNAL('updatedROI()'))
def add_conf_action(self, menu, obj, fp=False, txt=False):
"""Create a "Configure" action in menu and return it."""
if not fp:
fp = obj['fullpath']
if txt is False:
txt = 'Configure'
act = menu.addAction(
_(txt), functools.partial(self.configure_object, obj))
act.setCheckable(True)
self.conf_act[fp] = act
return act
def __init__(self, parent=None, context='Local'):
QtGui.QWidget.__init__(self, parent)
self.label = _('Connection Status')
self.setWindowTitle(self.label)
self.lay = QtGui.QVBoxLayout()
self.setLayout(self.lay)
self.connect(network.manager, QtCore.SIGNAL(
'connected()'), self.displayServerInfo)
self.addr = QtGui.QLabel()
self.lay.addWidget(self.addr)
self.displayServerInfo()
self.log = LiveLog(self)
self.lay.addWidget(self.log)
self.echo = QtGui.QLineEdit(self)
self.echo.setPlaceholderText(_("Test Echo Logging"))
self.echo.setMaxLength(50)
self.lay.addWidget(self.echo)
self.connect(
self.echo, QtCore.SIGNAL('returnPressed()'), self.sendEcho)
def __init__(self, sh, src='/hsm/sample0', parent=None):
QtGui.QDialog.__init__(self, parent=parent)
self.setWindowTitle(_('Video Export Configuration'))
self.lay = QtGui.QFormLayout()
self.setLayout(self.lay)
self.sh = sh
src = src.split('/')
exts = ('profile', 'frame', 'filteredProfile')
ext = 0
if src[-1] in exts:
ext = exts.index(src.pop(-1))
src = '/'.join(src)
T = src + '/T'
ropts = deepcopy(opts)
ropts['src']['current'] = src
ropts['T']['current'] = T
if ext:
ropts['ext']['current'] = ext
if 'Linux' in platform.platform():
ropts.pop('codec')
self.cfg = ConfigurationProxy({'self': ropts})
self.wg = conf.Interface(self.cfg, self.cfg, ropts)
self.lay.addRow(self.wg)
self.out = QtGui.QLineEdit()
self.out.setText(sh.get_path() + '.avi')
self.lbl_out = QtGui.QPushButton(_("Output file"))
self.lbl_out.pressed.connect(self.change_output)
self.lay.addRow(self.lbl_out, self.out)
self.btn_ok = QtGui.QPushButton("Start")
self.btn_ok.pressed.connect(self.export)
self.btn_ko = QtGui.QPushButton("Cancel")
self.btn_ko.pressed.connect(self.cancel)
self.btn_ko.setEnabled(False)
self.lay.addRow(self.btn_ko, self.btn_ok)
self.prog = False
def up(self, conditions={}, operator=1):
"""TODO: rename to select()"""
if not self.remote:
return
self.tests = self.remote.query(conditions, operator)
self.header = self.remote.header()
self.sheader = []
for h in self.header:
translation_key = 'dbcol:' + h
translation = _(translation_key, context="Option")
if translation == translation_key:
translation = h.capitalize()
self.sheader.append(translation)
QtCore.QAbstractTableModel.reset(self)
def up(self, conditions={}, operator=1):
"""TODO: rename to select()"""
if not self.remote:
return
self.tests = self.remote.query(conditions, operator)
self.header = self.remote.header()
self.sheader = []
for h in self.header:
translation_key = 'dbcol:' + h
translation = _(translation_key, context="Option")
if translation == translation_key:
translation = h.capitalize()
self.sheader.append(translation)
QtCore.QAbstractTableModel.reset(self)
def __init__(self, parent=None):
QtGui.QTableView.__init__(self, parent)
self.setModel(LiveLogModel())
self.label = _('Log')
self.menu = QtGui.QMenu(self)
self.menu.addAction('Update now', self.slotUpdate)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.setWordWrap(True)
self.setTextElideMode(QtCore.Qt.ElideLeft)
self.connect(
self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'), self.showMenu)
if registry != None:
self.connect(registry, QtCore.SIGNAL('log()'),
self.slotUpdate,
QtCore.Qt.QueuedConnection)
self.setFont(QtGui.QFont('TypeWriter', 7, 50, False))
self.slotUpdate()
def export(self):
"""Start export thread"""
prog = QtGui.QProgressBar()
self.lay.addRow(_('Rendering:'), prog)
src = str(self.src.text())
ext = str(self.ext.currentText())
if self.frm:
frm = str(self.frm.currentText())
fourcc = cv.VideoWriter_fourcc(*frm)
else:
fourcc = default_fourcc
out = str(self.out.text())
fps = self.fps.value()
self.prog = prog
export(self.sh, frame=src + '/' + ext, fourcc=fourcc,
output=out, framerate=fps, prog=prog,
acquisition_start_temperature=self.acquisition_start_temperature.value())
self.done(0)
def __init__(self, d='', T='', std='NIST-SRM738', start=50, end=50, label=True, add=True):
"""Make list of fields."""
self.fields = [
plugins.FieldDataset("d", descr=_("Expansion dataset"), default=d),
plugins.FieldDataset(
"T", descr=_("Temperature dataset"), default=T),
plugins.FieldCombo(
"std", descr=_("Calibraiton Standard"), items=standards.keys(), default=std),
plugins.FieldFloat(
'start', descr=_('First temperature margin'), default=start),
plugins.FieldFloat(
'end', descr=_('Last temperature margin'), default=end),
plugins.FieldBool(
'label', _('Draw calibration label'), default=label),
plugins.FieldBool(
'add', _('Add calibration datasets'), default=add),
]
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.setWindowTitle(_('Storyboard'))
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.strip = ImageStrip(parent=self)
self.connect(self.strip, QtCore.SIGNAL('set_time(float)'),
self.emitSetTime)
self.connect(self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.strip.showMenu)
self.stripArea = QtGui.QScrollArea(self)
self.stripArea.setWidgetResizable(True)
self.stripArea.setWidget(self.strip)
self.stripArea.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.stripArea,
QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.strip.showMenu)
# Slider for image navigation
self.slider = Slider(self)
self.slider.slider.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.slider.slider,
QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.strip.showMenu)
self.slider.menuButton.setMenu(self.strip.menu)
# self.connect(self.slider,QtCore.SIGNAL('set_idx(int)'),self.set_idx)
self.slider.slider.valueChanged.connect(self.strip.set_idx)
self.slider.slider.sliderMoved.connect(self.strip.set_idx)
self.connect(self.slider, QtCore.SIGNAL('datapathChanged(QString)'),
self.setPath)
self.lay = QtGui.QVBoxLayout()
self.lay.setContentsMargins(0, 0, 0, 0)
self.lay.setSpacing(0)
self.lay.addWidget(self.slider)
self.lay.addWidget(self.stripArea)
self.setLayout(self.lay)
self.connect(self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
self.strip.showMenu)
self.connect(self.slider, QtCore.SIGNAL('sliderReleased()'),
self.slider_released)
def __init__(self, n=5, parent=None):
QtGui.QWidget.__init__(self, parent)
self.lay = QtGui.QGridLayout()
self.setLayout(self.lay)
self.n = n
self.labels = []
self.menu = QtGui.QMenu(self)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(
self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'), self.showMenu)
self.menu.addAction(_('Change length'), self.chLen)
self.menu.addAction(_('Change rows'), self.chRows)
self.menu.addAction(_('Style'), self.chStyle)
self.actIndex = self.menu.addAction(_('Step by index'), self.by_index)
self.actIndex.setCheckable(True)
self.actTime = self.menu.addAction(_('Step by time'), self.by_time)
self.actTime.setCheckable(True)
self.menu.addAction(_("Export Images"), self.export_images)
self.menu.addAction(_("Render video"), self.render_video)
def __init__(self, info, parent=None):
QtGui.QWidget.__init__(self, parent)
self.info = info
self.lay = QtGui.QVBoxLayout(self)
self.setLayout(self.lay)
# self.setMaximumHeight(200)
# self.setMinimumHeight(200)
# self.setMinimumWidth(600)
self.grid = QtGui.QWidget(self)
self.glay = QtGui.QGridLayout(self.grid)
self.grid.setLayout(self.glay)
self.label = info.name + ' @' + info.addr
lbl = lambda txt, x, y: self.glay.addWidget(QtGui.QLabel(txt), x, y)
r = Inc()
cap = ', '.join(info.cap)
lbl('Name:', r.i(), 0)
lbl(info.name, r.n, 1)
lbl('Serial:', r.n, 2)
lbl(info.serial, r.n, 3)
lbl('Address:', r.i(), 0)
lbl(info.addr, r.n, 1)
lbl('IP:', r.n, 2)
lbl(str(info.ip), r.n, 3)
lbl('Host:', r.i(), 0)
lbl(info.host, r.n, 1)
lbl('Capabilities:', r.n, 2)
lbl(cap, r.n, 3)
lbl('Port:', r.i(), 0)
lbl(str(info.port), r.n, 1)
lbl('User:'******'Connect'), self)
self.lay.addWidget(self.button)
self.connect(
self.button, QtCore.SIGNAL('pressed()'), self.doConnection)
self.menu = QtGui.QMenu(self)
self.menu.addAction('Connect', self.doConnection)
self.connect(
self, QtCore.SIGNAL('customContextMenuRequested(QPoint)'), self.showMenu)
def __init__(self, remote=False, parent=None, browser=False):
QtGui.QWidget.__init__(self, parent)
self.remote = remote
loc = remote.addr
if loc == 'LOCAL':
loc = remote.dbPath
self.setWindowTitle(_('misura Database: ') + loc)
self.label = _('misura Database')
self.lay = QtGui.QVBoxLayout()
self.setLayout(self.lay)
self.menu = QtGui.QMenuBar(self)
self.menu.setNativeMenuBar(False)
self.lay.addWidget(self.menu)
self.table = DatabaseTable(self.remote, self, browser=browser)
self.lay.addWidget(self.table)
self.connect(self.table, QtCore.SIGNAL('selected()'), self.do_selected)
# Ricerca e controlli
wg = QtGui.QWidget(self)
lay = QtGui.QHBoxLayout()
wg.setLayout(lay)
self.lay.addWidget(wg)
lay.addWidget(QtGui.QLabel(_('Query:')))
self.qfilter = QtGui.QComboBox(self)
lay.addWidget(self.qfilter)
self.nameContains = QtGui.QLineEdit(self)
lay.addWidget(self.nameContains)
self.doQuery = QtGui.QPushButton(_('Apply'), parent=self)
lay.addWidget(self.doQuery)
self.connect(self.doQuery, QtCore.SIGNAL('clicked()'), self.query)
self.connect(
self.nameContains, QtCore.SIGNAL('returnPressed()'), self.query)
self.menu.addAction(_('Refresh'), self.refresh)
self.menu.addAction(_('Rebuild'), self.rebuild)
self.bar = QtGui.QProgressBar(self)
self.lay.addWidget(self.bar)
self.bar.hide()
self.resize(QtGui.QApplication.desktop().screen().rect().width(
) / 2, QtGui.QApplication.desktop().screen().rect().height() / 2)
def __init__(self, remote=False, parent=None, browser=False):
QtGui.QWidget.__init__(self, parent)
self.remote = remote
loc = remote.addr
if loc == 'LOCAL':
loc = remote.dbPath
self.setWindowTitle(_('misura Database: ') + loc)
self.label = _('misura Database')
self.lay = QtGui.QVBoxLayout()
self.setLayout(self.lay)
self.menu = QtGui.QMenuBar(self)
self.menu.setNativeMenuBar(False)
self.lay.addWidget(self.menu)
self.table = DatabaseTable(self.remote, self, browser=browser)
self.lay.addWidget(self.table)
self.connect(self.table, QtCore.SIGNAL('selected()'), self.do_selected)
# Ricerca e controlli
wg = QtGui.QWidget(self)
lay = QtGui.QHBoxLayout()
wg.setLayout(lay)
self.lay.addWidget(wg)
lay.addWidget(QtGui.QLabel(_('Query:')))
self.qfilter = QtGui.QComboBox(self)
lay.addWidget(self.qfilter)
self.nameContains = QtGui.QLineEdit(self)
lay.addWidget(self.nameContains)
self.doQuery = QtGui.QPushButton(_('Apply'), parent=self)
lay.addWidget(self.doQuery)
self.connect(self.doQuery, QtCore.SIGNAL('clicked()'), self.query)
self.connect(self.nameContains, QtCore.SIGNAL('returnPressed()'),
self.query)
self.menu.addAction(_('Refresh'), self.refresh)
self.menu.addAction(_('Rebuild'), self.rebuild)
self.bar = QtGui.QProgressBar(self)
self.lay.addWidget(self.bar)
self.bar.hide()
self.resize(QtGui.QApplication.desktop().screen().rect().width() / 2,
QtGui.QApplication.desktop().screen().rect().height() / 2)
def export_images(self):
output_filename = QtGui.QFileDialog.getSaveFileName(
self, _('Save Report'), '', '*.html')
if not output_filename:
return
instrument_name = self.decoder.datapath.split('/')[1]
sample_name = self.decoder.datapath.split('/')[2]
instrument = getattr(self.decoder.proxy.conf, instrument_name)
sample = getattr(instrument, sample_name)
opts = export_images_option_dialog(
self, max(self.doc.data.get('0:kiln/T').data))
if not opts:
return
characteristic_shapes = get_shapes(sample, opts['standard'])
self.export_aborted = False
thread = RunMethod(
htmlreport.create_images_report,
self.decoder,
instrument.measure,
characteristic_shapes,
startTemp=opts['start'],
step=opts['step'],
output=output_filename,
jobs=registry.tasks.jobs,
job=registry.tasks.job,
done=registry.tasks.done,
check_abort=self.check_abort_export,
do_abort=self.do_abort_export,
)
thread.pid = 'Creating images report'
thread.abort = self.do_abort_export
QtCore.QThreadPool.globalInstance().start(thread)
def change_output(self):
new = QtGui.QFileDialog.getSaveFileName(
self, _("Video output file"), filter=_("Video (*avi)"))
if len(new):
self.out.setText(new)
except:
login = False
if not login:
lw.exec_()
return lw.obj
class Inc(object):
n = 0
def i(self):
self.n += 1
return self.n
fail = _('Login Failed.')
class LoginWindow(QtGui.QDialog):
obj = False
login_failed = QtCore.pyqtSignal()
login_succeeded = QtCore.pyqtSignal()
def __init__(self, addr, user='******', password='******', mac='', globalconn=True, parent=None, context='Local'):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle('Login Required')
self.lay = QtGui.QGridLayout(self)
self.setLayout(self.lay)
self.addr = addr
self.mac = mac
self.userLbl = QtGui.QLabel(_('User Name') + ':')
self.pwdLbl = QtGui.QLabel(_('Password') + ':')
self.user = QtGui.QLineEdit(user)
def addActions(self):
"""Add actions to right-click context menu."""
self.menu.setTitle('Cam %s /dev/%s' %
(self.remote['name'], self.remote['dev']))
self.streamAct = self.menu.addAction('Stream', self.toggle)
self.streamAct.setCheckable(True)
self.autoresAct = self.menu.addAction('Fit view', self.unzoom)
# Camera configuration option
self.add_conf_action(self.menu, self.remote, self.fullpath)
self.bool_action('Simulation', 'Analysis_Simulation')
# Per-Sample Menu
self.menus = {}
# Controls Menu
self.imenu = self.menu.addMenu(_('Imaging'))
self.add_imaging_actions(self.imenu)
#########
# Analysis menu
#########
self.amenu = self.menu.addMenu(QtGui.QIcon(os.path.join(parameters.pathArt, 'morphometrics.svg')),
_('Morphometrics'))
# General view entries
self.roiAct = self.amenu.addAction(_('View Regions'),
functools.partial(self.over_by_name,
'roi'))
self.roiAct.setCheckable(True)
self.gridAct = self.amenu.addAction(_('Display Grids'), self.display_grids)
self.gridAct.setCheckable(True)
roiResetAct = self.amenu.addAction(_('Reset Regions'), self.reset_regions)
roiResetAct.setCheckable(False)
self.profileAct = self.amenu.addAction(_('Profile'),
functools.partial(self.over_by_name,
'profile'))
self.profileAct.setCheckable(True)
self.labelAct = self.amenu.addAction(_('Values Label'),
functools.partial(self.over_by_name,
'label'))
self.labelAct.setCheckable(True)
# Shape entries
is_hsm = '/hsm/' in self.remote['smp0'][0]
if is_hsm:
self.pointsAct = self.amenu.addAction(_('Points'),
functools.partial(self.over_by_name,
'points'))
self.pointsAct.setCheckable(True)
self.baseHeightAct = self.amenu.addAction(_('Base and Height'),
functools.partial(self.over_by_name,
'baseHeight'))
self.baseHeightAct.setCheckable(True)
self.circleAct = self.amenu.addAction(_('Circle Fitting'),
functools.partial(self.over_by_name,
'circle'))
self.circleAct.setCheckable(True)
else:
self.referenceLineAct = self.amenu.addAction(_('Reference line'),
functools.partial(self.over_by_name,
'referenceLine'))
self.referenceLineAct.setCheckable(True)
self.regressionLineAct = self.amenu.addAction(_('Regression line'),
functools.partial(self.over_by_name,
'regressionLine'))
self.regressionLineAct.setCheckable(True)
self.filteredProfileAct =self.amenu.addAction(_('Filtered profile'),
functools.partial(self.over_by_name,
'filteredProfile'))
self.filteredProfileAct.setCheckable(True)
# Border entries
# TODO: Border overlays
# Pixel Calibration
self.calAct = self.amenu.addAction(
'Pixel Calibration', self.calibration)
self.calAct.setCheckable(True)
# Remove tool action if modification is not allowed
if not self.remote.check_write('Analysis_umpx'):
self.amenu.removeAction(self.calAct)
#########
# Motion menu
#########
self.mmenu = self.menu.addMenu(_('Motion'))
self.add_motion_actions(self.mmenu)
# Other stuff
self.menu.addAction('Save frame', self.save_frame)
def apply(self, cmd, fields):
"""Do the work of the plugin.
cmd: veusz command line interface object (exporting commands)
fields: dict mapping field names to values
"""
self.ops = []
self.doc = cmd.document
ds = self.doc.data[fields['d']]
Ts = self.doc.data[fields['T']]
# Convert to percent, if possible
self.inidim = getattr(ds, 'm_initialDimension', False)
if not getattr(ds, 'm_percent', False):
if self.inidim:
ds = units.percent_conversion(ds, 'To Percent', auto=False)
T = Ts.data
# Cut away any cooling
while max(T) != T[-1]:
i = np.where(T == max(T))[0]
T = T[:i]
d = ds.data[:len(T)]
# Standard
sT, sd = standards[fields['std']]
# Find start/end T
start = max(sT[0], T[0]) + fields['start']
end = min(sT[-1], T[-1]) - fields['end']
# Cut datasets
si = find_nearest_val(T, start, get=T.__getitem__)
ei = find_nearest_val(T, end, get=T.__getitem__)
logging.debug( 'Cutting', si, ei)
T = T[si:ei]
d = d[si:ei]
logging.debug('T start, end', start, end)
f = InterpolatedUnivariateSpline(sT, sd, k=2)
s0 = f(T[0])
s_slope = (f(T[-1]) - s0) / (T[-1] - T[0]) # Standard slope
self.f = f
self.s_slope = s_slope
# Just use to get linearity residuals
(quad, slope, const), res, rank, sing, rcond = np.polyfit(
T, d, 2, full=True)
self.quad = quad
z_slope = (d[-1] - d[0]) / (T[-1] - T[0]) # Sample slope
z_const = ds.data[0]
res = np.sqrt(res[0] / len(T))
# Convert from percentage to micron
um = res * self.inidim / 100
factor = s_slope / z_slope
micron = u'\u03bcm'
msg = _('Calibration factor: {} \nStandard deviation: \n {} %\n {} {}').format(
factor, res, um, micron)
self.msg = msg
self.slope, self.const = slope, const
self.fld, self.ds, self.T, self.d, self.sT, self.sd = fields, ds, T, d, sT, sd
self.factor, self.res, self.um = factor, res, um
if fields['label']:
self.label()
if fields['add']:
self.add_datasets(si, d[0])
self.apply_ops()
self.doc.model.refresh()
return factor, res
def apply(self, cmd, fields):
"""Do the work of the plugin.
cmd: veusz command line interface object (exporting commands)
fields: dict mapping field names to values
"""
self.ops = []
self.doc = cmd.document
ds = self.doc.data[fields['d']]
Ts = self.doc.data[fields['T']]
# Convert to percent, if possible
self.inidim = getattr(ds, 'm_initialDimension', False)
if not getattr(ds, 'm_percent', False):
if self.inidim:
ds = units.percent_conversion(ds, 'To Percent', auto=False)
T = Ts.data
# Cut away any cooling
while max(T) != T[-1]:
i = np.where(T == max(T))[0]
T = T[:i]
d = ds.data[:len(T)]
# Standard
sT, sd = standards[fields['std']]
# Find start/end T
start = max(sT[0], T[0]) + fields['start']
end = min(sT[-1], T[-1]) - fields['end']
# Cut datasets
si = find_nearest_val(T, start, get=T.__getitem__)
ei = find_nearest_val(T, end, get=T.__getitem__)
logging.debug('Cutting', si, ei)
T = T[si:ei]
d = d[si:ei]
logging.debug('T start, end', start, end)
f = InterpolatedUnivariateSpline(sT, sd, k=2)
s0 = f(T[0])
s_slope = (f(T[-1]) - s0) / (T[-1] - T[0]) # Standard slope
self.f = f
self.s_slope = s_slope
# Just use to get linearity residuals
(quad, slope, const), res, rank, sing, rcond = np.polyfit(T,
d,
2,
full=True)
self.quad = quad
z_slope = (d[-1] - d[0]) / (T[-1] - T[0]) # Sample slope
z_const = ds.data[0]
res = np.sqrt(res[0] / len(T))
# Convert from percentage to micron
um = res * self.inidim / 100
factor = s_slope / z_slope
micron = u'\u03bcm'
msg = _(
'Calibration factor: {} \nStandard deviation: \n {} %\n {} {}'
).format(factor, res, um, micron)
self.msg = msg
self.slope, self.const = slope, const
self.fld, self.ds, self.T, self.d, self.sT, self.sd = fields, ds, T, d, sT, sd
self.factor, self.res, self.um = factor, res, um
if fields['label']:
self.label()
if fields['add']:
self.add_datasets(si, d[0])
self.apply_ops()
self.doc.model.refresh()
return factor, res
class CalibrationFactorPlugin(utils.OperationWrapper, plugins.ToolsPlugin):
"""Dilatometry calibration factor calculation"""
# a tuple of strings building up menu to place plugin on
menu = ('Misura', _('Calibration factor'))
# unique name for plugin
name = 'Calibration Factor'
# name to appear on status tool bar
description_short = _('Dilatometry calibration factor')
# text to appear in dialog box
description_full = _(
'Get calibration factor from standard expansion curve')
preserve = True
def __init__(self,
d='',
T='',
std='NIST-SRM738',
start=50,
end=50,
label=True,
add=True):
"""Make list of fields."""
self.fields = [
plugins.FieldDataset("d", descr=_("Expansion dataset"), default=d),
plugins.FieldDataset("T",
descr=_("Temperature dataset"),
default=T),
plugins.FieldCombo("std",
descr=_("Calibraiton Standard"),
items=standards.keys(),
default=std),
plugins.FieldFloat('start',
descr=_('First temperature margin'),
default=start),
plugins.FieldFloat('end',
descr=_('Last temperature margin'),
default=end),
plugins.FieldBool('label',
_('Draw calibration label'),
default=label),
plugins.FieldBool('add',
_('Add calibration datasets'),
default=add),
]
def apply(self, cmd, fields):
"""Do the work of the plugin.
cmd: veusz command line interface object (exporting commands)
fields: dict mapping field names to values
"""
self.ops = []
self.doc = cmd.document
ds = self.doc.data[fields['d']]
Ts = self.doc.data[fields['T']]
# Convert to percent, if possible
self.inidim = getattr(ds, 'm_initialDimension', False)
if not getattr(ds, 'm_percent', False):
if self.inidim:
ds = units.percent_conversion(ds, 'To Percent', auto=False)
T = Ts.data
# Cut away any cooling
while max(T) != T[-1]:
i = np.where(T == max(T))[0]
T = T[:i]
d = ds.data[:len(T)]
# Standard
sT, sd = standards[fields['std']]
# Find start/end T
start = max(sT[0], T[0]) + fields['start']
end = min(sT[-1], T[-1]) - fields['end']
# Cut datasets
si = find_nearest_val(T, start, get=T.__getitem__)
ei = find_nearest_val(T, end, get=T.__getitem__)
logging.debug('Cutting', si, ei)
T = T[si:ei]
d = d[si:ei]
logging.debug('T start, end', start, end)
f = InterpolatedUnivariateSpline(sT, sd, k=2)
s0 = f(T[0])
s_slope = (f(T[-1]) - s0) / (T[-1] - T[0]) # Standard slope
self.f = f
self.s_slope = s_slope
# Just use to get linearity residuals
(quad, slope, const), res, rank, sing, rcond = np.polyfit(T,
d,
2,
full=True)
self.quad = quad
z_slope = (d[-1] - d[0]) / (T[-1] - T[0]) # Sample slope
z_const = ds.data[0]
res = np.sqrt(res[0] / len(T))
# Convert from percentage to micron
um = res * self.inidim / 100
factor = s_slope / z_slope
micron = u'\u03bcm'
msg = _(
'Calibration factor: {} \nStandard deviation: \n {} %\n {} {}'
).format(factor, res, um, micron)
self.msg = msg
self.slope, self.const = slope, const
self.fld, self.ds, self.T, self.d, self.sT, self.sd = fields, ds, T, d, sT, sd
self.factor, self.res, self.um = factor, res, um
if fields['label']:
self.label()
if fields['add']:
self.add_datasets(si, d[0])
self.apply_ops()
self.doc.model.refresh()
return factor, res
def add_datasets(self, start_index, start_value):
"""Add standard and fitted datasets for further evaluations (plotting, etc)"""
# Adding plot data
fields = self.fld
name = fields['std'].replace(' ', '_')
p = fields['d'] + '/' + name
Tds = self.doc.data[fields['T']]
T = Tds.data
old_unit = getattr(self.ds, 'old_unit', 'percent')
# Fitting
# f=np.poly1d((self.slope,0))
f = np.poly1d((self.quad, self.slope, 0))
df = f(T)
df += start_value - df[start_index]
# TODO: define new derived datasets for these
dsf = copy(Tds)
dsf.attr = dict({}, **Tds.attr)
dsf.tags = set([])
dsf.data = plugins.numpyCopyOrNone(df)
dsf.m_var = name + '_fit'
dsf.m_pos = 2
dsf.m_name = dsf.m_var
dsf.m_col = dsf.m_var
dsf.old_unit = old_unit
dsf.unit = 'percent'
dsf.m_initialDimension = self.inidim
dsf.m_label = _('Calibration Fitting')
self.ops.append(document.OperationDatasetSet(p + '_fit', dsf))
# Evaluate std fit over regular T
d = self.f(T)
# Translate zero so it matches the fit
d -= d[start_index] - df[start_index]
dsd = copy(Tds)
dsd.attr = dict({}, **Tds.attr)
dsd.tags = set([])
dsd.data = plugins.numpyCopyOrNone(d)
dsd.m_var = name
dsd.m_pos = 1
dsd.m_name = name
dsd.m_col = name
dsd.unit = 'percent'
dsd.old_unit = old_unit
dsd.m_initialDimension = self.inidim
dsd.m_label = _(name)
self.ops.append(document.OperationDatasetSet(p, dsd))
def label(self):
"""Draw label"""
cur = self.fld.get('currentwidget')
g = self.doc.resolveFullWidgetPath(cur)
g = utils.searchFirstOccurrence(g, ['graph', 'page'])
if g is None or g.typename not in ['graph', 'page']:
raise plugins.ToolsPluginException(
'Impossible to draw the label. Select a page or a graph.')
name = 'lbl_' + self.fld['d'].replace('summary/', '').replace('/', '_')
if not g.getChild(name):
self.ops.append(document.OperationWidgetAdd(g, 'label', name=name))
self.apply_ops(self.name + ':CreateLabel')
lbl = g.getChild(name)
self.toset(lbl, 'label', self.msg.replace('\n', '\\\\'))
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.lay = QtGui.QVBoxLayout(self)
self.setLayout(self.lay)
self.setWindowTitle(_('Remote Pending Tasks'))
self._lock = threading.Lock()
def change_output(self):
new = QtGui.QFileDialog.getSaveFileName(self,
_("Video output file"),
filter=_("Video (*avi)"))
if len(new):
self.out.setText(new)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.lay = QtGui.QVBoxLayout(self)
self.setLayout(self.lay)
self.setWindowTitle(_('Remote Pending Tasks'))
self._lock = threading.Lock()
i += 1
if prog:
QtGui.qApp.processEvents()
if pg > 1 and prog.value() == 0:
logging.debug('Export cancelled at frame', i)
break
pg = i - i0
prog.setValue(pg)
logging.debug('releasing', output)
out.release()
return True
opts = {}
ao(opts, 'src', 'String', '', _('Sample source'))
ao(opts, 'T', 'String', '', _('Temperature source'))
ao(opts,
'ext',
'Chooser',
'profile',
_('Rendering source'),
options=['profile', 'frame'])
ao(opts, 'startTemp', 'Float', 0, _('Start temperature'))
ao(opts,
'fps',
'Integer',
50,
_('Framerate'),
min=1,
max=100,
def __init__(self, sh, src='/hsm/sample0', parent=None):
QtGui.QDialog.__init__(self, parent=parent)
self.setWindowTitle(_('Video Export Configuration'))
self.lay = QtGui.QFormLayout()
self.setLayout(self.lay)
self.sh = sh
src = src.split('/')
exts = ('profile', 'frame')
ext = 0
if src[-1] in exts:
ext = exts.index(src.pop(-1))
src = '/'.join(src)
self.src = QtGui.QLineEdit()
self.src.setText(src)
self.lay.addRow(_("Sample source"), self.src)
self.ext = QtGui.QComboBox()
self.ext.addItem("profile")
self.ext.addItem("frame")
self.ext.setCurrentIndex(ext)
self.lay.addRow(_("Rendering source"), self.ext)
# self.meta=QtGui.QListWidget()
# for k in ['Sintering','Softening','Sphere','HalfSphere','Melting']:
# it=QtGui.QListWidgetItem(k)
# it.setCheckState(0)
# self.meta.addItem(it)
## self.lay.addRow(_("Render metadata"),self.meta)
##
# self.vals=QtGui.QListWidget()
# for k in ['T','Vol','h']:
# it=QtGui.QListWidgetItem(k)
# it.setCheckState(0)
# self.vals.addItem(it)
## self.lay.addRow(_("Render values"),self.vals)
if 'Linux' in platform.platform():
self.frm = QtGui.QComboBox()
self.frm.addItem('X264')
self.frm.addItem('XVID')
self.frm.addItem('MJPG')
self.frm.setCurrentIndex(0)
self.lay.addRow(_("Output Video Codec"), self.frm)
else:
self.frm = False
self.fps = QtGui.QDoubleSpinBox()
self.fps.setMinimum(1)
self.fps.setMaximum(100)
self.fps.setValue(50)
self.lay.addRow(_("Framerate"), self.fps)
self.acquisition_start_temperature = QtGui.QSpinBox()
self.acquisition_start_temperature.setMinimum(1)
self.acquisition_start_temperature.setMaximum(2000)
self.acquisition_start_temperature.setValue(20)
self.lay.addRow(_("Start acquisition at temperature"), self.acquisition_start_temperature)
self.out = QtGui.QLineEdit()
self.out.setText(sh.get_path() + '.avi')
self.lbl_out = QtGui.QPushButton(_("Output file"))
self.lbl_out.pressed.connect(self.change_output)
self.lay.addRow(self.lbl_out, self.out)
self.btn_ok = QtGui.QPushButton("Start")
self.btn_ok.pressed.connect(self.export)
self.btn_ko = QtGui.QPushButton("Cancel")
self.btn_ko.pressed.connect(self.cancel)
self.lay.addRow(self.btn_ko, self.btn_ok)
self.prog = False
