class FitParam(object):
def __init__(self,
name,
value,
mini,
maxi,
logscale=False,
steps=5000,
format='%.3f',
size_offset=0,
unit=''):
self.name = name
self.value = value
self.min = mini if logscale == False else max(1e-120, mini)
self.max = maxi
self.logscale = logscale
self.steps = steps
self.format = format
self.unit = unit
self.prefix_label = None
self.lineedit = None
self.unit_label = None
self.slider = None
self.button = None
self._widgets = []
self._size_offset = size_offset
self._refresh_callback = None
self.dataset = FitParamDataSet(title=_("Curve fitting parameter"))
def copy(self):
"""Return a copy of this fitparam"""
return self.__class__(self.name, self.value, self.min, self.max,
self.logscale, self.steps, self.format,
self._size_offset, self.unit)
def create_widgets(self, parent, refresh_callback):
self._refresh_callback = refresh_callback
self.prefix_label = QLabel()
font = self.prefix_label.font()
font.setPointSize(font.pointSize() + self._size_offset)
self.prefix_label.setFont(font)
self.button = QPushButton()
self.button.setIcon(get_icon('settings.png'))
self.button.setToolTip(
_("Edit '%s' fit parameter properties") % self.name)
QObject.connect(self.button, SIGNAL('clicked()'),
lambda: self.edit_param(parent))
self.lineedit = QLineEdit()
QObject.connect(self.lineedit, SIGNAL('editingFinished()'),
self.line_editing_finished)
self.unit_label = QLabel(self.unit)
self.slider = QSlider()
self.slider.setOrientation(Qt.Horizontal)
self.slider.setRange(0, self.steps - 1)
QObject.connect(self.slider, SIGNAL("valueChanged(int)"),
self.slider_value_changed)
self.update(refresh=False)
self.add_widgets([
self.prefix_label, self.lineedit, self.unit_label, self.slider,
self.button
])
def add_widgets(self, widgets):
self._widgets += widgets
def get_widgets(self):
return self._widgets
def set_scale(self, state):
self.logscale = state > 0
self.update_slider_value()
def set_text(self, fmt=None):
style = "<span style=\'color: #444444\'><b>%s</b></span>"
self.prefix_label.setText(style % self.name)
if self.value is None:
value_str = ''
else:
if fmt is None:
fmt = self.format
value_str = fmt % self.value
self.lineedit.setText(value_str)
self.lineedit.setDisabled(self.value == self.min
and self.max == self.min)
def line_editing_finished(self):
try:
self.value = float(self.lineedit.text())
except ValueError:
self.set_text()
self.update_slider_value()
self._refresh_callback()
def slider_value_changed(self, int_value):
if self.logscale:
#~ total_delta = np.log10(1+self.max-self.min)
#~ self.value = self.min+10**(total_delta*int_value/(self.steps-1))-1
#~ total_delta = np.log10(self.max)-np.log10(self.min)
ratio = int_value / (self.steps - 1)
self.value = self.max**ratio * self.min**(1 - ratio)
else:
total_delta = self.max - self.min
self.value = self.min + total_delta * int_value / (self.steps - 1)
self.set_text()
self._refresh_callback()
def update_slider_value(self):
from numpy import isnan, isinf
if (self.value is None or self.min is None or self.max is None):
self.slider.setEnabled(False)
if self.slider.parent() and self.slider.parent().isVisible():
self.slider.show()
elif self.value == self.min and self.max == self.min:
self.slider.hide()
else:
self.slider.setEnabled(True)
if self.slider.parent() and self.slider.parent().isVisible():
self.slider.show()
if self.logscale:
value_delta = max([np.log10(self.value / self.min), 0.])
total_delta = np.log10(self.max / self.min)
if not isnan(self.steps * value_delta / total_delta):
intval = int(self.steps * value_delta / total_delta)
else:
intval = int(self.min)
else:
value_delta = self.value - self.min
total_delta = self.max - self.min
intval = int(self.steps * value_delta / total_delta)
self.slider.blockSignals(True)
print intval
print
sys.stdout.flush()
self.slider.setValue(intval)
self.slider.blockSignals(False)
def edit_param(self, parent):
update_dataset(self.dataset, self)
if self.dataset.edit(parent=parent):
restore_dataset(self.dataset, self)
if self.value > self.max:
self.max = self.value
if self.value < self.min:
self.min = self.value
self.update(True)
def update(self, refresh=True):
self.unit_label.setText(self.unit)
self.slider.setRange(0, self.steps - 1)
self.update_slider_value()
self.set_text()
if refresh:
self._refresh_callback()
class MotorizedLinearPoti(COMCUPluginBase):
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletMotorizedLinearPoti, *args)
self.mp = self.device
self.cbe_position = CallbackEmulator(self.mp.get_position,
self.cb_position,
self.increase_error_count)
self.current_position = None
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 100)
self.slider.setMinimumWidth(200)
self.slider.setEnabled(False)
plots = [('Potentiometer Position', Qt.red, lambda: self.current_position, str)]
self.plot_widget = PlotWidget('Position', plots, extra_key_widgets=[self.slider],
curve_motion_granularity=40, update_interval=0.025)
self.motor_slider = QSlider(Qt.Horizontal)
self.motor_slider.setRange(0, 100)
self.motor_slider.valueChanged.connect(self.motor_slider_value_changed)
self.motor_hold_position = QCheckBox("Hold Position")
self.motor_drive_mode = QComboBox()
self.motor_drive_mode.addItem('Fast')
self.motor_drive_mode.addItem('Smooth')
def get_motor_slider_value():
return self.motor_slider.value()
self.motor_hold_position.stateChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value()))
self.motor_drive_mode.currentIndexChanged.connect(lambda x: self.motor_slider_value_changed(get_motor_slider_value()))
self.motor_position_label = MotorPositionLabel('Motor Target Position:')
hlayout = QHBoxLayout()
hlayout.addWidget(self.motor_position_label)
hlayout.addWidget(self.motor_slider)
hlayout.addWidget(self.motor_drive_mode)
hlayout.addWidget(self.motor_hold_position)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(hlayout)
def start(self):
async_call(self.mp.get_position, None, self.cb_position, self.increase_error_count)
async_call(self.mp.get_motor_position, None, self.cb_motor_position, self.increase_error_count)
self.cbe_position.set_period(25)
self.plot_widget.stop = False
def stop(self):
self.cbe_position.set_period(0)
self.plot_widget.stop = True
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletMotorizedLinearPoti.DEVICE_IDENTIFIER
def cb_position(self, position):
self.current_position = position
self.slider.setValue(position)
def cb_motor_position(self, motor):
self.motor_slider.blockSignals(True)
self.motor_hold_position.blockSignals(True)
self.motor_drive_mode.blockSignals(True)
self.motor_hold_position.setChecked(motor.hold_position)
self.motor_drive_mode.setCurrentIndex(motor.drive_mode)
self.motor_position_label.setText(str(motor.position))
self.motor_slider.setValue(motor.position)
self.motor_slider.blockSignals(False)
self.motor_hold_position.blockSignals(False)
self.motor_drive_mode.blockSignals(False)
def motor_slider_value_changed(self, position):
self.motor_position_label.setText(str(position))
self.mp.set_motor_position(self.motor_slider.value(), self.motor_drive_mode.currentIndex(), self.motor_hold_position.isChecked())
class CMainWindow(QFrame):
def __init__(self):
QMainWindow.__init__(self)
layout = QGridLayout(self)
layout.setMargin(2)
btnFiles = QPushButton(u'Файлы', self)
btnVideo = QPushButton(u'Видео', self)
btnPlay = QPushButton(u'Play/Pause', self)
btnStop = QPushButton(u'Stop', self)
btnMute = QPushButton(u'Mute', self)
btnMute.setCheckable(True)
btnMainMenu = QPushButton(u'Main', self)
self.sldVolume = QSlider(Qt.Vertical, self)
self.sldPosition = QSlider(Qt.Horizontal, self)
self.layMain = QStackedLayout()
btnFiles.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
btnVideo.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
btnPlay.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
btnStop.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
btnMute.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
btnMainMenu.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.sldVolume.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.sldPosition.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
layout.addWidget(btnFiles, 0, 0)
layout.addWidget(btnVideo, 0, 1)
layout.addWidget(btnPlay, 0, 3)
layout.addWidget(btnStop, 0, 4)
layout.addWidget(btnMute, 0, 5)
layout.addWidget(btnMainMenu, 2, 5)
layout.addWidget(self.sldVolume, 1, 5)
layout.addWidget(self.sldPosition, 2, 0, 1, 5)
layout.addLayout(self.layMain, 1, 0, 1, 5)
fileBrowser = CFileBrowser(self)
self.videoWidget = QWidget(self)
self.exitMenu = CExitMenu(self)
self.mplayer = MPlayerControl(self, self.videoWidget)
fileBrowser.chosen.connect(self.startPlay)
btnFiles.clicked.connect(lambda: self.selectMode(0))
btnVideo.clicked.connect(lambda: self.selectMode(1))
btnMainMenu.clicked.connect(lambda: self.selectMode(2))
self.sldPosition.valueChanged.connect(self.mplayer.seek)
self.sldVolume.valueChanged.connect(self.mplayer.setvol)
btnMute.clicked.connect(lambda: self.mplayer.mute(btnMute.isChecked()))
btnPlay.clicked.connect(self.mplayer.play)
btnStop.clicked.connect(self.mplayer.stop)
self.sldVolume.setValue(QtGui.qApp.settings['volume'])
self.mplayer.percent_position.connect(self.on_mplayer_position)
self.layMain.addWidget(fileBrowser)
self.layMain.addWidget(self.videoWidget)
self.layMain.addWidget(self.exitMenu)
@pyqtSlot(int)
def on_mplayer_position(self, pos):
self.sldPosition.blockSignals(True)
self.sldPosition.setValue(pos)
self.sldPosition.blockSignals(False)
@pyqtSlot(int)
def selectMode(self, mode):
self.layMain.setCurrentIndex(mode)
@pyqtSlot(str)
def startPlay(self, path):
self.selectMode(1)
self.mplayer.play(path)
def closeEvent(self, event):
self.mplayer.quit()
QFrame.closeEvent(self, event)
