def __init__(self):
QWidget.__init__(self)
self._status = "unknown"
self._layout = QGridLayout(self)
self._widgets = dict()
self.__logging_cb_signal.connect(self.logging_cb)
self.__start_logging_signal.connect(self.start_logging)
self.__stop_logging_signal.connect(self.stop_logging)
self._add_widget("pid_label", QLabel("PID:", self))
self._add_widget("pid", QLineEdit(self))
self._widgets["pid"].setMaximumWidth(50)
self._add_widget("label_status", QLabel(self))
self._widgets["label_status"].setText("Status: Unknown")
self._widgets["label_status"].setTextFormat(QtCore.Qt.RichText)
self._add_widget("button_start", QPushButton("START", self))
self._add_widget("button_stop", QPushButton("STOP", self))
self._widgets["button_start"].clicked.connect(
self.__start_logging_signal.emit)
self._widgets["button_stop"].clicked.connect(
self.__stop_logging_signal.emit)
self._widgets["label_warning"] = QLabel(self)
self._layout.addWidget(self._widgets["label_warning"], 1, 0, 1, 2)
self._widgets["label_warning"].setTextFormat(QtCore.Qt.RichText)
rospy.Subscriber("/data_logger/status", String,
self.__logging_cb_signal.emit)
self._logging_start = rospy.ServiceProxy('/data_logger/start',
DataLoggerStart)
self._logging_stop = rospy.ServiceProxy('/data_logger/stop',
DataLoggerStop)
def __init__(self, check_state_changed_callback, topic_name, parent=None, is_topic = False):
super(TreeWidgetItem, self).__init__(parent)
self._check_state_changed_callback = check_state_changed_callback
self._topic_name = topic_name
self.setCheckState(CHECK_COLUMN, Qt.Unchecked)
self._is_topic = is_topic
self._slider = QSlider(Qt.Horizontal)
self._hbox = QHBoxLayout()
self._min_label = QLabel("min")
self._max_label = QLabel("max")
self._hbox.addWidget(self._min_label)
self._hbox.addWidget(self._slider)
self._hbox.addWidget(self._max_label)
tree = self.treeWidget()
widget = QWidget()
widget.setLayout(self._hbox)
# tree.setItemWidget(self, 3, widget)
self.setTextAlignment(self._column_names.index("min"), Qt.AlignRight | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("max"), Qt.AlignLeft | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("value"), Qt.AlignHCenter | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("type"), Qt.AlignHCenter | Qt.AlignVCenter)
self.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable )
self._slider.valueChanged.connect(self.sliderValueChanged)
def __init__(self):
super(TemporaryTask_dialog, self).__init__()
self.setObjectName('TemporaryTask_dialog')
# Load ui file
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_simulation'),
'resource', 'temporary_task.ui')
loadUi(ui_file, self)
self.button_add.clicked.connect(self.add_eventually)
self.button_remove.clicked.connect(self.remove_eventually)
self.button_cancel.clicked.connect(self.cancel)
self.button_send.clicked.connect(self.send_task)
# Make whole dialog scrollable
self.grid = QGridLayout()
self.scrollAreaWidgetContents.setLayout(self.grid)
self.atomic_propositions = []
self.eventually_label_list = []
eventually_label = QLabel('<> (')
self.eventually_label_list.append(eventually_label)
self.grid.addWidget(eventually_label, 0, 0)
self.eventually_input_list = []
eventually_input = QLineEdit()
self.eventually_input_list.append(eventually_input)
self.grid.addWidget(eventually_input, 0, 1)
self.end_bracket_list = []
end_bracket = QLabel(')')
self.end_bracket_list.append(end_bracket)
self.grid.addWidget(end_bracket, 0, 2)
def __init__(self, context):
super(SpectrogramPlugin, self).__init__(context)
self.setObjectName('Spectrogram')
sns.set(style="whitegrid", palette="bright", color_codes=True)
self._widget = QWidget()
layout = QVBoxLayout()
self._widget.setLayout(layout)
layout_ = QHBoxLayout()
self.lbl_topic = QLabel('Topic:')
layout_.addWidget(self.lbl_topic)
self.le_topic = QLineEdit()
layout_.addWidget(self.le_topic)
self.apply_topic = QPushButton("Apply")
self.apply_topic.clicked.connect(self.apply_clicked_topic)
layout_.addWidget(self.apply_topic)
layout.addLayout(layout_)
layout_ = QHBoxLayout()
self.lbl_lcf = QLabel('Low-cut Freq.[Hz]:')
layout_.addWidget(self.lbl_lcf)
self.spb_lcf = QSpinBox()
self.spb_lcf.setRange(0, 50)
self.spb_lcf.setValue(0)
layout_.addWidget(self.spb_lcf)
self.apply_lcf = QPushButton("Apply")
self.apply_lcf.clicked.connect(self.apply_clicked_lcf)
layout_.addWidget(self.apply_lcf)
layout.addLayout(layout_)
layout_ = QHBoxLayout()
self.lbl_hcf = QLabel('High-cut Freq.[Hz]:')
layout_.addWidget(self.lbl_hcf)
self.spb_hcf = QSpinBox()
self.spb_hcf.setRange(50, self.vib_freq / 2)
self.spb_hcf.setValue(self.vib_freq / 2)
layout_.addWidget(self.spb_hcf)
self.apply_hcf = QPushButton("Apply")
self.apply_hcf.clicked.connect(self.apply_clicked_hcf)
layout_.addWidget(self.apply_hcf)
layout.addLayout(layout_)
#self.fig, self.axes = plt.subplots(2, 1, sharex=True)
self.fig = plt.figure()
self.ax = self.fig.add_subplot(1, 1, 1)
self.canvas = FigureCanvas(self.fig)
self.fig.tight_layout()
layout.addWidget(self.canvas)
context.add_widget(self._widget)
self.update_signal.connect(self.update_spectrogram)
self.subscriber_signal.connect(self.update_subscriber)
self.subscriber_signal.emit('spectrum')
def __populate_self(self):
i = 1
if len(self.topic_fields) == 0:
fields = RosHelper.get_all_msg_fields(self.topic_type)
else:
fields = self.topic_fields
for field in fields:
self.ref_dict[field] = QLabel("None",self)
self.layout.addWidget(QLabel(field,self),i,1)
self.layout.addWidget(self.ref_dict[field],i,2)
i+=1
self.setLayout(self.layout)
def add_item_to_conversation_view(self, msg, type=0):
label_msg = QLabel(msg)
label_msg.setWordWrap(True)
label_msg.setStyleSheet('font-size:10pt;')
inner_text_layout = QHBoxLayout()
horizonalSpacer1 = QSpacerItem(0, 0, QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
if type == 0:
inner_text_layout.addWidget(label_msg)
inner_text_layout.addItem(horizonalSpacer1)
elif type == 1:
inner_text_layout.addItem(horizonalSpacer1)
inner_text_layout.addWidget(label_msg)
inner_layout = QVBoxLayout()
time_msg = QLabel(str(time.asctime(time.localtime(time.time()))))
time_msg.setStyleSheet('font-size:8pt;')
inner_layout.addItem(inner_text_layout)
inner_layout.addWidget(time_msg)
inner_layout.setSizeConstraint(QLayout.SetFixedSize)
outer_layout = QHBoxLayout()
horizonalSpacer2 = QSpacerItem(0, 0, QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
if type == 0:
label_msg.setStyleSheet(
'background: #e5e5ea; padding: 6px; border-radius: 8px;')
time_msg.setAlignment(Qt.AlignLeft)
outer_layout.addItem(inner_layout)
outer_layout.addItem(horizonalSpacer2)
elif type == 1:
label_msg.setStyleSheet(
'background: #1d86f4; padding: 6px; border-radius: 8px; color:#fff;'
)
time_msg.setAlignment(Qt.AlignRight)
outer_layout.addItem(horizonalSpacer2)
outer_layout.addItem(inner_layout)
outer_layout.setSizeConstraint(QLayout.SetMinimumSize)
widget = QWidget()
widget.setLayout(outer_layout)
widget.resize(widget.sizeHint())
item = QListWidgetItem()
item.setSizeHint(widget.sizeHint())
self._widget.listWidget.addItem(item)
self._widget.listWidget.setItemWidget(item, widget)
self._widget.listWidget.scrollToBottom()
def motor_controller(self):
'''
Sets up the GUI in the middle of the Screen to control the motors.
Uses self._motorValues to determine which motors are present.
'''
i = 0
for k, v in sorted(self._currentGoals.items()):
group = QGroupBox()
slider = QSlider(Qt.Horizontal)
slider.setTickInterval(1)
slider.setMinimum(-181)
slider.setMaximum(181)
slider.valueChanged.connect(self.slider_update)
self._sliders[k] = slider
textfield = QLineEdit()
textfield.setText('0')
textfield.textEdited.connect(self.textfield_update)
self._textFields[k] = textfield
label = QLabel()
label.setText(k)
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(self._sliders[k])
layout.addWidget(self._textFields[k])
group.setLayout(layout)
self._widget.motorControlLayout.addWidget(group, i / 5, i % 5)
i = i+1
def __init__(self,
options,
title='Checkboxes',
selected_indexes=[],
parent=None):
super(CheckBoxGroup, self).__init__()
self.setTitle(title)
self.setLayout(QVBoxLayout())
self._button_group = QButtonGroup()
self._button_group.setExclusive(False)
self._options = options
if parent == None:
parent = self
for (button_id, option) in enumerate(self._options):
checkbox = QCheckBox(option.get('title', 'option %d' % button_id))
checkbox.setEnabled(option.get('enabled', True))
checkbox.setChecked(button_id in selected_indexes)
checkbox.setToolTip(option.get('tooltip', ''))
self._button_group.addButton(checkbox, button_id)
parent.layout().addWidget(checkbox)
if 'description' in option:
parent.layout().addWidget(QLabel(option['description']))
def __init__(self):
super(StringLabelWidget, self).__init__()
self.lock = Lock()
vbox = QVBoxLayout(self)
self.label = QLabel()
self.label.setAlignment(Qt.AlignLeft)
self.label.setSizePolicy(
QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
font = QFont("Helvetica", 14)
self.label.setFont(font)
self.label.setWordWrap(True)
vbox.addWidget(self.label)
self.string_sub = None
self._string_topics = []
self._update_topic_timer = QTimer(self)
self._update_topic_timer.timeout.connect(self.updateTopics)
self._update_topic_timer.start(1000)
self._active_topic = None
# to update label visualization
self._dialog = LineEditDialog()
self._rosdata = None
self._start_time = rospy.get_time()
self._update_label_timer = QTimer(self)
self._update_label_timer.timeout.connect(self.updateLabel)
self._update_label_timer.start(40)
def update(self):
self.clean()
if not self.request:
rospy.logwarn('question dialog: no request, update ignored')
return
req = self.request
self._text_browser.setText(req.message)
if req.type == QuestionDialogRequest.DISPLAY:
# All done, nothing more too see here.
self.response = QuestionDialogResponse(
QuestionDialogRequest.NO_RESPONSE, "")
self.response_ready = True
elif req.type == QuestionDialogRequest.CHOICE_QUESTION:
for index, options in enumerate(req.options):
button = QPushButton(options, self._widget)
button.clicked.connect(partial(self.handle_button, index))
row = index / 3
col = index % 3
self._button_layout.addWidget(button, row, col)
self.buttons.append(button)
elif req.type == QuestionDialogRequest.TEXT_QUESTION:
self.text_label = QLabel("Enter here: ", self._widget)
self._button_layout.addWidget(self.text_label, 0, 0)
self.text_input = QLineEdit(self._widget)
self.text_input.editingFinished.connect(self.handle_text)
self._button_layout.addWidget(self.text_input, 0, 1)
def __init__(self, updater, config, nodename):
"""
:param config:
:type config: Dictionary? defined in dynamic_reconfigure.client.Client
:type nodename: str
"""
super(GroupWidget, self).__init__()
self.state = config['state']
self.param_name = config['name']
self._toplevel_treenode_name = nodename
# TODO: .ui file needs to be back into usage in later phase.
# ui_file = os.path.join(rp.get_path('rqt_reconfigure'),
# 'resource', 'singlenode_parameditor.ui')
# loadUi(ui_file, self)
verticalLayout = QVBoxLayout(self)
verticalLayout.setContentsMargins(QMargins(0, 0, 0, 0))
_widget_nodeheader = QWidget()
_h_layout_nodeheader = QHBoxLayout(_widget_nodeheader)
_h_layout_nodeheader.setContentsMargins(QMargins(0, 0, 0, 0))
self.nodename_qlabel = QLabel(self)
font = QFont('Trebuchet MS, Bold')
font.setUnderline(True)
font.setBold(True)
# Button to close a node.
_icon_disable_node = QIcon.fromTheme('window-close')
_bt_disable_node = QPushButton(_icon_disable_node, '', self)
_bt_disable_node.setToolTip('Hide this node')
_bt_disable_node_size = QSize(36, 24)
_bt_disable_node.setFixedSize(_bt_disable_node_size)
_bt_disable_node.pressed.connect(self._node_disable_bt_clicked)
_h_layout_nodeheader.addWidget(self.nodename_qlabel)
_h_layout_nodeheader.addWidget(_bt_disable_node)
self.nodename_qlabel.setAlignment(Qt.AlignCenter)
font.setPointSize(10)
self.nodename_qlabel.setFont(font)
grid_widget = QWidget(self)
self.grid = QFormLayout(grid_widget)
verticalLayout.addWidget(_widget_nodeheader)
verticalLayout.addWidget(grid_widget, 1)
# Again, these UI operation above needs to happen in .ui file.
self.tab_bar = None # Every group can have one tab bar
self.tab_bar_shown = False
self.updater = updater
self.editor_widgets = []
self._param_names = []
self._create_node_widgets(config)
logging.debug('Groups node name={}'.format(nodename))
self.nodename_qlabel.setText(nodename)
def __init__(self, tf_static_broadcast, parent_frame, child_frame, initPos,
*args):
super(_TfFrameEditor, self).__init__(*args)
self.tf_static_broadcast = tf_static_broadcast
self.msg = TransformStamped()
self.msg.header.frame_id = parent_frame
self.msg.child_frame_id = child_frame
self.layout = QFormLayout(self)
self.layout.addRow(
QLabel("Static pose from {} to {}".format(parent_frame,
child_frame)))
def wdgt(label, value, trans):
import math
sb = QDoubleSpinBox()
m = 1e3 if trans else math.pi
sb.setRange(-m, m)
sb.setDecimals(4)
sb.setSingleStep(1e-3 if trans else .05)
sb.setSuffix(" m" if trans else " rad")
self.layout.addRow(label, sb)
sb.setValue(value)
sb.valueChanged.connect(self.valueChanged)
return sb
self.tx = wdgt("X", initPos[0], True)
self.ty = wdgt("Y", initPos[1], True)
self.tz = wdgt("Z", initPos[2], True)
self.rr = wdgt("Roll", initPos[3], False)
self.rp = wdgt("Pitch", initPos[4], False)
self.ry = wdgt("Yaw", initPos[5], False)
self.valueChanged()
def __init__(self,
options,
title='Exclusive Options',
selected_index=None,
parent=None):
super(ExclusiveOptionGroup, self).__init__()
self.setTitle(title)
self.setLayout(QVBoxLayout())
self._button_group = QButtonGroup()
self._button_group.setExclusive(True)
self._options = options
if parent == None:
parent = self
for (button_id, option) in enumerate(self._options):
radio_button = QRadioButton(
option.get('title', 'option %d' % button_id))
radio_button.setEnabled(option.get('enabled', True))
radio_button.setChecked(
option.get('selected', False) or button_id == selected_index)
radio_button.setToolTip(option.get('tooltip', ''))
self._button_group.addButton(radio_button, button_id)
parent.layout().addWidget(radio_button)
if 'description' in option:
parent.layout().addWidget(QLabel(option['description']))
def beginRosLabel(self,obj):
pm,lm = self.__get_immediate_parent()
fr = QFrame(pm)
layout = QGridLayout()
nlb = QLabel(obj.label_name + ":",fr)
nlb.setToolTip(obj.topic_name)
layout.addWidget(nlb,1,1)
layout.addWidget(RosLabel(fr,obj.label_name,obj.topic_name,obj.topic_type,obj.topic_field),1,2)
fr.setLayout(layout)
lm.addWidget(fr)
def __init__(self):
super(Dashboard, self).__init__()
not_latched = False
# latched = True
self.publishers = py_trees_ros.utilities.Publishers([
('scan', "~scan", std_msgs.Empty, not_latched, 1),
('cancel', "~cancel", std_msgs.Empty, not_latched, 1),
])
self.scan_push_button = QPushButton("Scan")
self.scan_push_button.setStyleSheet("QPushButton { font-size: 30pt; }")
self.scan_push_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.scan_push_button.pressed.connect(
functools.partial(self.publish_button_message,
self.publishers.scan))
self.cancel_push_button = QPushButton("Cancel")
self.cancel_push_button.setStyleSheet(
"QPushButton { font-size: 30pt; }")
self.cancel_push_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.cancel_push_button.pressed.connect(
functools.partial(self.publish_button_message,
self.publishers.cancel))
self.led_strip_flashing = False
self.led_strip_on_count = 1
self.led_strip_colour = "grey"
self.led_strip_lock = threading.Lock()
self.led_strip_timer = QTimer()
self.led_strip_timer.timeout.connect(self.led_strip_timer_callback)
self.led_strip_label = QLabel("LED Strip")
self.led_strip_label.setAlignment(Qt.AlignCenter)
self.led_strip_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.led_strip_label.setStyleSheet(
"background-color: %s; font-size: 30pt;" % self.led_strip_colour)
self.hbox_layout = QGridLayout(self)
self.hbox_layout.addWidget(self.scan_push_button)
self.hbox_layout.addWidget(self.cancel_push_button)
self.hbox_layout.addWidget(self.led_strip_label)
self.subscribers = py_trees_ros.utilities.Subscribers([
("report", "/tree/report", std_msgs.String,
self.reality_report_callback),
("led_strip", "/led_strip/display", std_msgs.String,
self.led_strip_display_callback)
])
self.led_strip_timer.start(500) # ms
def add_eventually(self):
for i in range(0, len(self.end_bracket_list)):
self.grid.removeWidget(self.end_bracket_list[0])
self.end_bracket_list[0].deleteLater()
del self.end_bracket_list[0]
self.end_bracket_list = []
eventually_label = QLabel('& <> (')
position = len(self.eventually_label_list) + len(
self.eventually_input_list)
self.eventually_label_list.append(eventually_label)
self.grid.addWidget(eventually_label, 0, position + 1)
eventually_input = QLineEdit()
self.eventually_input_list.append(eventually_input)
self.grid.addWidget(eventually_input, 0, position + 2)
for i in range(0, len(self.eventually_label_list)):
end_bracket = QLabel(')')
self.end_bracket_list.append(end_bracket)
self.grid.addWidget(end_bracket, 0, position + 3 + i)
def __init__(self, bagFiles, parent=None):
super(QualityDialog, self).__init__()
self.parent = parent
self.bagFiles = bagFiles
self.setWindowTitle("Data Quality")
## Widgets:
self.spinBox = QDoubleSpinBox()
self.spinBox.setDecimals(2)
self.spinBox.setMaximum(1.0)
self.spinBox.setSingleStep(0.1)
self.spinBox.setValue(0.5)
self.fppiLbl = QLabel("FPPI = ")
self.motaLbl = QLabel("MOTA = ")
self.motpLbl = QLabel("MOTP = ")
self.recalcBtn = QPushButton("Recalculate Quality")
self.recalcBtn.clicked.connect(self.calculate)
## Layout:
layout = QVBoxLayout()
layout.addWidget(self.spinBox)
layout.addWidget(self.fppiLbl)
layout.addWidget(self.motaLbl)
layout.addWidget(self.motpLbl)
layout.addWidget(self.recalcBtn)
self.setLayout(layout)
self.resize(300, 200)
# calculate the data quality:
self.calculate()
def create_gait(self, name, gait, selections):
gait_group_box = QGroupBox()
gait_group_box.setObjectName('Gait')
gait_group_box.setLayout(QHBoxLayout())
gait_group_box.setTitle(name)
image = QLabel()
image.setStyleSheet(
'background: url(' + gait['image'] + ') no-repeat center center 100px 100px;')
image.setFixedSize(64, 80)
gait_group_box.layout().addWidget(image)
for subgait_name, subgait in gait['subgaits'].iteritems():
subgait_group_box = self.create_subgait(subgait_name, subgait, selections)
gait_group_box.layout().addWidget(subgait_group_box)
return gait_group_box
def getBallLabel(self, colorStr):
"""
sets the ball label
:param colorStr: the color fo the ball as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getBallFile(colorStr))
ball = QLabel(parent=self.frame)
ball.setPixmap(pxmap)
ball.setScaledContents(True)
ball.setFixedSize(self.size, self.size)
ball.show()
return ball
else:
ball = ls.pop()
ball.show()
return ball
def getUndefLabel(self, colorStr):
"""
initiates the undefined label
:param colorStr: color as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getUndefFile(colorStr))
undf = QLabel(parent=self.frame)
undf.setPixmap(pxmap)
undf.setScaledContents(True)
undf.setFixedSize(self.size, self.size)
undf.show()
return undf
else:
undf = ls.pop()
undf.show()
return undf
def getTeammateLabel(self, colorStr):
"""
initaties the teammate label for the quarter field
:param colorStr: color as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getTeammateFile(colorStr))
mate = QLabel(parent=self.frame)
mate.setPixmap(pxmap)
mate.setScaledContents(True)
mate.setFixedSize(self.size, self.size)
mate.show()
return mate
else:
mate = ls.pop()
mate.show()
return mate
def getOpponentLabel(self, colorStr):
"""
initiates the opponent label
:param colorStr: color as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getOpponentFile(colorStr))
opp = QLabel(parent=self.frame)
opp.setPixmap(pxmap)
opp.setScaledContents(True)
opp.setFixedSize(self.size, self.size)
opp.show()
return opp
else:
opp = ls.pop()
opp.show()
return opp
def getCrossLabel(self, colorStr):
"""
initiates the cross label
:param colorStr: color as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getCrossFile(colorStr))
crs = QLabel(parent=self.frame)
crs.setPixmap(pxmap)
crs.setScaledContents(True)
crs.setFixedSize(self.size, self.size)
crs.show()
return crs
else:
crs = ls.pop()
crs.show()
return crs
def getRobotLabel(self, colorStr):
"""
initiates the robot label
:param colorStr: color as string
:return:
"""
ls = self.pool.get(colorStr)
if ls == []:
pxmap = QPixmap(self._getRobFile(colorStr))
rob = QLabel(parent=self.frame)
rob.setPixmap(pxmap)
rob.originalPixmap = QPixmap(pxmap)
rob.setScaledContents(True)
rob.setFixedSize(self.size, self.size)
rob.show()
return rob
else:
rob = ls.pop()
rob.show()
return rob
def __init__(self, params, id_radio):
super(inputDialog, self).__init__()
self.id_radio = id_radio
self.center()
layout = QFormLayout()
self.label_items = []
self.label_comment = dict()
self.client_answers_items = []
self.greather_conditions = []
self.button_clicked = False
# print params
for item in params:
param = item[0]
label = item[1]
cond = item[2]
if not label == "":
label = " (%s)" % label
self.greather_conditions.append((param, cond))
label_item = QLabel(param + label, self)
# self.label_items[param] = QLabel(param + label, self)
label_item.setAlignment(Qt.AlignCenter)
self.label_items.append(param)
client_answers = QLineEdit()
self.client_answers_items.append(client_answers)
# self.label_comment[label] = QLabel(label, self)
# self.label_comment[label].setAlignment(Qt.AlignCenter)
# layout.addWidget(self.label_comment[label])
layout.addRow(label_item, client_answers)
self.ok_button = QPushButton("ok", self)
self.ok_button.clicked.connect(self.onButtonClicked)
layout.addWidget(self.ok_button)
self.setLayout(layout)
self.setWindowTitle("Update Parameters")
self.show()
def __init__(self, context):
super(LevelSelectorPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('LevelSelectorPlugin')
# Create QWidget
self._widget = QWidget()
self._widget.setFont(QFont("Times", 15, QFont.Bold))
self._button_layout = QVBoxLayout(self._widget)
self.buttons = []
self.text_label = QLabel("Waiting for MultiLevelMapData...", self._widget)
self._button_layout.addWidget(self.text_label)
self._widget.setObjectName('LevelSelectorPluginUI')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle()
+ (' (%d)' % context.serial_number()))
context.add_widget(self._widget)
self.button_signal.connect(self.update_buttons)
self.button_status_signal.connect(self.update_button_status)
# Subscribe to the multi level map data to get information about all the maps.
self.multimap_subscriber = rospy.Subscriber("map_metadata", MultiLevelMapData,
self.process_multimap)
self.levels = []
self.current_level = None
rospy.loginfo('level selector: subscribed to maps')
# Subscribe to the current level we are on.
self.status_subscriber = None
# Create a service proxy to change the current level.
self.level_selector_proxy = rospy.ServiceProxy("level_mux/change_current_level",
ChangeCurrentLevel)
self.level_selector_proxy.wait_for_service()
rospy.loginfo('level selector: found "level_mux/change_current_level" service')
def create_progressbar(self, aircraft_no):
waypoint_layout = QVBoxLayout()
waypoint_layout.setContentsMargins(0, 10, 0, 10)
waypoint_header_layout = QHBoxLayout(
) # waypoint_header_layout will be nested inside waypoint_layout with the progress bar beneath it
aircraft_label = QLabel('Aircraft ' + str(aircraft_no))
self.waypoint_plaintext_dict['aircraft' +
str(aircraft_no)] = QPlainTextEdit()
self.waypoint_plaintext_dict.get('aircraft' +
str(aircraft_no)).setMaximumHeight(40)
self.waypoint_plaintext_dict.get('aircraft' +
str(aircraft_no)).setReadOnly(True)
self.waypoint_plaintext_dict[
'aircraftlink' + str(aircraft_no)] = QPlainTextEdit("Telegram")
self.waypoint_plaintext_dict.get('aircraftlink' +
str(aircraft_no)).setMaximumHeight(40)
self.waypoint_plaintext_dict.get('aircraftlink' +
str(aircraft_no)).setMaximumWidth(100)
self.waypoint_plaintext_dict.get('aircraftlink' +
str(aircraft_no)).setReadOnly(True)
self.waypoint_plaintext_dict['progress_bar_aircraft' +
str(aircraft_no)] = QProgressBar()
waypoint_header_layout.addWidget(aircraft_label)
waypoint_header_layout.addWidget(
self.waypoint_plaintext_dict['aircraft' + str(aircraft_no)])
waypoint_header_layout.addWidget(
self.waypoint_plaintext_dict['aircraftlink' + str(aircraft_no)])
waypoint_layout.addLayout(waypoint_header_layout)
waypoint_layout.addWidget(
self.waypoint_plaintext_dict['progress_bar_aircraft' +
str(aircraft_no)])
self.progressbar_layout.addLayout(waypoint_layout)
def remove_eventually(self):
for i in range(0, len(self.end_bracket_list)):
self.grid.removeWidget(self.end_bracket_list[0])
self.end_bracket_list[0].deleteLater()
del self.end_bracket_list[0]
self.end_bracket_list = []
self.grid.removeWidget(self.eventually_label_list[-1])
self.eventually_label_list[-1].deleteLater()
del self.eventually_label_list[-1]
self.grid.removeWidget(self.eventually_input_list[-1])
self.eventually_input_list[-1].deleteLater()
del self.eventually_input_list[-1]
position = len(self.eventually_label_list) + len(
self.eventually_input_list)
for i in range(0, len(self.eventually_label_list)):
end_bracket = QLabel(')')
self.end_bracket_list.append(end_bracket)
self.grid.addWidget(end_bracket, 0, position + 1 + i)
def __init__(self, title, jsp, num_rows=0):
super(JointStatePublisherGui, self).__init__()
self.jsp = jsp
self.joint_map = {}
self.vlayout = QVBoxLayout(self)
self.scrollable = QWidget()
self.gridlayout = QGridLayout()
self.scroll = QScrollArea()
self.scroll.setWidgetResizable(True)
font = QFont("Helvetica", 9, QFont.Bold)
### Generate sliders ###
sliders = []
for name in self.jsp.joint_list:
if name not in self.jsp.free_joints:
continue
joint = self.jsp.free_joints[name]
if joint['min'] == joint['max']:
continue
joint_layout = QVBoxLayout()
row_layout = QHBoxLayout()
label = QLabel(name)
label.setFont(font)
row_layout.addWidget(label)
display = QLineEdit("0.00")
display.setAlignment(Qt.AlignRight)
display.setFont(font)
display.setReadOnly(True)
row_layout.addWidget(display)
joint_layout.addLayout(row_layout)
slider = QSlider(Qt.Horizontal)
slider.setFont(font)
slider.setRange(0, RANGE)
slider.setValue(RANGE / 2)
joint_layout.addWidget(slider)
self.joint_map[name] = {
'slidervalue': 0,
'display': display,
'slider': slider,
'joint': joint
}
# Connect to the signal provided by QSignal
slider.valueChanged.connect(
lambda event, name=name: self.onValueChangedOne(name))
sliders.append(joint_layout)
# Determine number of rows to be used in grid
self.num_rows = num_rows
# if desired num of rows wasn't set, default behaviour is a vertical layout
if self.num_rows == 0:
self.num_rows = len(sliders) # equals VBoxLayout
# Generate positions in grid and place sliders there
self.positions = self.generate_grid_positions(len(sliders),
self.num_rows)
for item, pos in zip(sliders, self.positions):
self.gridlayout.addLayout(item, *pos)
# Set zero positions read from parameters
self.center()
# Synchronize slider and displayed value
self.sliderUpdate(None)
# Set up a signal for updating the sliders based on external joint info
self.sliderUpdateTrigger.connect(self.updateSliders)
self.scrollable.setLayout(self.gridlayout)
self.scroll.setWidget(self.scrollable)
self.vlayout.addWidget(self.scroll)
# Buttons for randomizing and centering sliders and
# Spinbox for on-the-fly selecting number of rows
self.randbutton = QPushButton('Randomize', self)
self.randbutton.clicked.connect(self.randomize_event)
self.vlayout.addWidget(self.randbutton)
self.ctrbutton = QPushButton('Center', self)
self.ctrbutton.clicked.connect(self.center_event)
self.vlayout.addWidget(self.ctrbutton)
self.maxrowsupdown = QSpinBox()
self.maxrowsupdown.setMinimum(1)
self.maxrowsupdown.setMaximum(len(sliders))
self.maxrowsupdown.setValue(self.num_rows)
self.maxrowsupdown.valueChanged.connect(self.reorggrid_event)
self.vlayout.addWidget(self.maxrowsupdown)
self.setLayout(self.vlayout)
def __init__(self, bag_files, listtopics, duration):
super(BagParser, self).__init__()
# window title
self.setWindowTitle("Making csv file")
# size of window
self.resize(960, 720)
#self.showFullScreen()
#self.setWindowState(Qt.WindowMaximized)
# print listtopics
# print E.get_general_features_options()
# print E.get_specific_features_options()
self.topics_items = dict()
self.topics_items["0"] = listtopics
self.topics_items["1"] = E.get_general_features_options()
self.topics_items["2"] = E.get_specific_features_options()
print self.topics_items
#path to bag file
self.bag_files = bag_files
self.selected_bag_topics = []
self.selected_specific_features = []
self.selected_general_features = []
self.items_list_topics = []
self.area = QScrollArea(self)
self.areagen = QScrollArea(self)
self.areaspec = QScrollArea(self)
self.main_widget = QWidget(self.area)
self.main_widget1 = QWidget(self.areagen)
self.main_widget2 = QWidget(self.areaspec)
self.ok_button = QPushButton("Export To CSV", self)
#self.ok_button.setFixedSize(150, 30)
self.ok_button.clicked.connect(self.onButtonClicked)
self.clear_button = QPushButton("Clear Selection", self)
# self.clear_button.resize(self.clear_button.sizeHint())
self.clear_button.clicked.connect(self.onClearClicked)
self.choose_button = QPushButton("Get Last Export Choose", self)
self.choose_button.clicked.connect(self.onButtonChooseCliked)
self.ok_button.setEnabled(False)
self.label1 = QLabel("Select topic from bag(s)", self)
self.label1.setAlignment(Qt.AlignCenter)
self.label2 = QLabel("Statistics Features", self)
self.label2.setAlignment(Qt.AlignCenter)
self.label3 = QLabel("Specific Features", self)
self.label3.setAlignment(Qt.AlignCenter)
self.duration = duration
self.label5 = QLabel("Duration Time: " + str("%.1f" % duration), self)
self.label5.setAlignment(Qt.AlignCenter)
self.main_vlayout = QVBoxLayout(self)
# self.main_vlayout = QGridLayout(self)
self.main_vlayout.addWidget(self.label1)
self.main_vlayout.addWidget(self.area)
self.main_vlayout.addWidget(self.label2)
self.main_vlayout.addWidget(self.areagen)
self.main_vlayout.addWidget(self.label3)
self.main_vlayout.addWidget(self.areaspec)
self.label4 = QLabel("Window time", self)
self.label4.setAlignment(Qt.AlignCenter)
# self.main_vlayout.addWidget(self.label4)
self.window = QLineEdit(self)
# self.main_vlayout.addWidget(self.window)
self.window.setText("1")
self.windows_time_3 = QHBoxLayout(self)
self.windows_time_3.addWidget(self.label4)
self.windows_time_3.addWidget(self.window)
self.windows_time_3.addWidget(self.label5)
self.main_vlayout.addLayout(self.windows_time_3)
# self.window = QLineEdit(self)
# self.window.setText("1")
# self.box = QVBoxLayout()
# self.box.addStretch(1)
# self.box.addWidget(self.clear_button)
# self.box.addWidget(self.choose_button)
# self.box.addWidget(self.label4)
# self.box.addWidget(self.window)
# self.box.addWidget(self.label5)
# self.box.addWidget(self.ok_button)
#self.main_vlayout.addWidget(self.from_nodes_button)
# self.main_vlayout.addLayout(self.box)
self.two_buttons = QHBoxLayout(self)
self.two_buttons.addWidget(self.choose_button)
self.two_buttons.addWidget(self.clear_button)
self.main_vlayout.addLayout(self.two_buttons)
self.main_vlayout.addWidget(self.ok_button)
self.setLayout(self.main_vlayout)
self.selection_vlayout = QVBoxLayout(self)
self.item_all = MyQCheckBox("All", self, self.selection_vlayout, None)
self.item_all.stateChanged.connect(
lambda x: self.updateList(x, self.item_all, None))
self.selection_vlayout.addWidget(self.item_all)
topic_data_list = listtopics
topic_data_list.sort()
for topic in topic_data_list:
self.addCheckBox(topic, self.selection_vlayout,
self.selected_bag_topics)
self.selection_vlayout1 = QVBoxLayout(self)
self.item_all1 = MyQCheckBox("All", self, self.selection_vlayout1,
None)
self.item_all1.stateChanged.connect(
lambda x: self.updateList(x, self.item_all1, None))
self.selection_vlayout1.addWidget(self.item_all1)
topic_data_list1 = E.get_general_features_options()
topic_data_list1.sort()
for topic in topic_data_list1:
self.addCheckBox(topic, self.selection_vlayout1,
self.selected_general_features)
self.selection_vlayout2 = QVBoxLayout(self)
self.item_all2 = MyQCheckBox("All", self, self.selection_vlayout2,
None)
self.item_all2.stateChanged.connect(
lambda x: self.updateList(x, self.item_all2, None))
self.selection_vlayout2.addWidget(self.item_all2)
topic_data_list2 = E.get_specific_features_options()
topic_data_list2.sort()
for topic in topic_data_list2:
self.addCheckBox(topic, self.selection_vlayout2,
self.selected_specific_features)
self.main_widget.setLayout(self.selection_vlayout)
self.main_widget1.setLayout(self.selection_vlayout1)
self.main_widget2.setLayout(self.selection_vlayout2)
self.area.setWidget(self.main_widget)
self.areagen.setWidget(self.main_widget1)
self.areaspec.setWidget(self.main_widget2)
self.show()
