def __init__(self, parent=None, logger=Logger()):
QWidgetWithLogger.__init__(self, parent, logger)
# start widget
vbox = QVBoxLayout()
vbox.setMargin(0)
vbox.setContentsMargins(0, 0, 0, 0)
# parameter action server topic selection
topic_widget = QTopicWidget(
self, 'vigir_generic_params/GetParameterSetNamesAction', True)
vbox.addWidget(topic_widget)
# parameter set selection
self.parameter_set_selection_widget = QParameterSetSelectionWidget(
self, logger)
self.parameter_set_selection_widget.param_cleared_signal.connect(
self.param_cleared)
self.parameter_set_selection_widget.param_changed_signal.connect(
self.param_changed)
topic_widget.topic_changed_signal.connect(self.topic_changed)
topic_widget.topic_changed_signal.connect(
self.parameter_set_selection_widget.set_topic_name)
vbox.addWidget(self.parameter_set_selection_widget)
# end widget
self.setLayout(vbox)
# init widget
topic_widget.emit_topic_name()
def __init__(self, status):
super(InspectorWidget, self).__init__()
self.status = status
self.setWindowTitle(status.name)
self.paused = False
layout = QVBoxLayout()
self.disp = QTextEdit()
self.snapshot = QPushButton("Snapshot")
self.time = TimelineWidget(self)
layout.addWidget(self.disp, 1)
layout.addWidget(self.time, 0)
layout.addWidget(self.snapshot)
self.snaps = []
self.snapshot.clicked.connect(self.take_snapshot)
self.write.connect(self.write_kv)
self.newline.connect(lambda: self.disp.insertPlainText('\n'))
self.clear.connect(lambda: self.disp.clear())
self.setLayout(layout)
self.setGeometry(0,0,300,400)
self.show()
self.update(status)
def __init__(self, tabwidget, parent=None):
QDockWidget.__init__(self, "Find", parent)
self.setObjectName('SearchFrame')
self.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetFloatable)
self._dockwidget = QFrame(self)
self.vbox_layout = QVBoxLayout(self._dockwidget)
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(1)
# frame with two rows for find and replace
find_replace_frame = QFrame(self)
find_replace_vbox_layout = QVBoxLayout(find_replace_frame)
find_replace_vbox_layout.setContentsMargins(0, 0, 0, 0)
find_replace_vbox_layout.setSpacing(1)
# find_replace_vbox_layout.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Expanding))
# create frame with find row
find_frame = self._create_find_frame()
find_replace_vbox_layout.addWidget(find_frame)
rplc_frame = self._create_replace_frame()
find_replace_vbox_layout.addWidget(rplc_frame)
# frame for find&replace and search results
self.vbox_layout.addWidget(find_replace_frame)
self.vbox_layout.addWidget(self._create_found_frame())
# self.vbox_layout.addStretch(2024)
self.setWidget(self._dockwidget)
# intern search parameters
self._tabwidget = tabwidget
self.current_search_text = ''
self.search_results = []
self.search_results_fileset = set()
self._search_result_index = -1
self._search_recursive = False
self._search_thread = None
def _update_client_list(self, service_name):
service_list = self.admin_app_info.service_list
client_list = service_list[service_name]["client_list"]
self._widget.client_tab_widget.clear()
for k in client_list.values():
client_name = k["name"]
k["index"] = self._widget.client_tab_widget.count()
main_widget = QWidget()
ver_layout = QVBoxLayout(main_widget)
ver_layout.setContentsMargins(9, 9, 9, 9)
ver_layout.setSizeConstraint(ver_layout.SetDefaultConstraint)
sub_widget = QWidget()
sub_widget.setAccessibleName('sub_widget')
ver_layout.addWidget(sub_widget)
client_context_widget = QPlainTextEdit()
client_context_widget.setObjectName(client_name + '_' +
'app_context_widget')
client_context_widget.setAccessibleName('app_context_widget')
client_context_widget.appendPlainText("client name is " +
client_name)
#ap><b>uuidp_context_widget.appendHtml(k["app_context"])
ver_layout.addWidget(client_context_widget)
#add tab
self._widget.client_tab_widget.addTab(main_widget, client_name)
pass
def __init__(self, context):
super(SpectrogramPlugin, self).__init__(context)
self.setObjectName('Spectrogram')
self._widget = QWidget()
layout = QVBoxLayout()
self._widget.setLayout(layout)
layout_ = QHBoxLayout()
self.line_edit = QLineEdit()
layout_.addWidget(self.line_edit)
self.apply_btn = QPushButton("Apply")
self.apply_btn.clicked.connect(self.apply_clicked)
layout_.addWidget(self.apply_btn)
layout.addLayout(layout_)
self.fig = Figure((5, 4), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.axes = self.fig.add_subplot(111)
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('spec')
def __init__(self, context):
super(GhostRobotControlPlugin, self).__init__(context)
self.setObjectName('GhostRobotControlPlugin')
self.joint_states_to_ghost_pub = rospy.Publisher('/joint_states_to_ghost', JointState, queue_size=10)
self.ghost_joint_states_sub = rospy.Subscriber('/ghost/joint_states', JointState, self.ghost_joint_states_cb)
self.real_joint_states_sub = rospy.Subscriber('/atlas/joint_states', JointState, self.real_joint_states_cb)
self.ghost_joint_states = JointState()
self.real_joint_states = JointState()
self.move_real_robot = False
self.widget = QWidget()
vbox = QVBoxLayout()
self.real_to_ghost_push_button = QPushButton('Set Ghost from real robot')
self.real_to_ghost_push_button.clicked.connect(self.handle_set_real_to_ghost)
vbox.addWidget(self.real_to_ghost_push_button)
self.send_motion_plan_to_real_robot_check_box = QCheckBox('Motion GUI moves real robot')
self.send_motion_plan_to_real_robot_check_box.stateChanged.connect(self.handle_send_motion_plan_to_real_robot_check_box)
vbox.addWidget(self.send_motion_plan_to_real_robot_check_box)
self.widget.setLayout(vbox)
context.add_widget(self.widget)
def add_widget(self, widget):
if widget in self._embed_widgets:
qWarning(
'PluginHandlerXEmbedClient.add_widget() widget "%s" already added'
% widget.objectName())
return
embed_widget = QX11EmbedWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(widget)
embed_widget.setLayout(layout)
# close embed widget when container is closed
# TODO necessary?
#embed_widget.containerClosed.connect(embed_widget.close)
embed_container_window_id = self._remote_container.embed_widget(
os.getpid(), widget.objectName())
embed_widget.embedInto(embed_container_window_id)
signaler = WindowChangedSignaler(widget, widget)
signaler.window_icon_changed_signal.connect(
self._on_embed_widget_icon_changed)
signaler.window_title_changed_signal.connect(
self._on_embed_widget_title_changed)
self._embed_widgets[widget] = embed_widget, signaler
# trigger to update initial window icon and title
signaler.window_icon_changed_signal.emit(widget)
signaler.window_title_changed_signal.emit(widget)
embed_widget.show()
def __init__(self, context):
super(RescueControlDialog, self).__init__(context)
self.setObjectName('RescueControlDialog')
self.joint_states_pub={}
self._widget = QWidget()
vbox = QVBoxLayout()
#Add a Pushbutton for resetting the system state
resetPushButton = QPushButton("Reset State")
resetPushButton.pressed.connect(self.handleReset)
self._syscommand_pub = rospy.Publisher('syscommand', String)
vbox.addWidget(resetPushButton)
#Add a Pushbutton for adding a victim in front of the robot and projecting it against the wall
addVictimInFrontOfRobotPushButton = QPushButton("Add victim in front of robot")
addVictimInFrontOfRobotPushButton.pressed.connect(self.on_add_victim_in_front_of_robot_pressed)
vbox.addWidget(addVictimInFrontOfRobotPushButton)
#add stretch at end so all GUI elements are at top of dialog
vbox.addStretch(1)
self._widget.setLayout(vbox)
context.add_widget(self._widget)
def add_toolbar(self, toolbar):
if toolbar in self._embed_widgets:
qWarning(
'PluginHandlerXEmbedClient.add_toolbar() toolbar "%s" already added'
% toolbar.objectName())
return
embed_widget = QX11EmbedWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(toolbar)
embed_widget.setLayout(layout)
# close embed widget when container is closed
# TODO necessary?
#embed_widget.containerClosed.connect(embed_widget.close)
def foo():
print('embed_widget.containerClosed')
embed_widget.containerClosed.connect(foo)
embed_container_window_id = self._remote_container.embed_toolbar(
os.getpid(), toolbar.objectName())
embed_widget.embedInto(embed_container_window_id)
self._embed_widgets[toolbar] = embed_widget, None
embed_widget.show()
def __init__(self, parent=None, current_values=None):
super(BlacklistDialog, self).__init__(parent)
self.setWindowTitle("Blacklist")
vbox = QVBoxLayout()
self.setLayout(vbox)
self._blacklist = Blacklist()
if isinstance(current_values, list):
for val in current_values:
self._blacklist.append(val)
vbox.addWidget(self._blacklist)
controls_layout = QHBoxLayout()
add_button = QPushButton(icon=QIcon.fromTheme('list-add'))
rem_button = QPushButton(icon=QIcon.fromTheme('list-remove'))
ok_button = QPushButton("Ok")
cancel_button = QPushButton("Cancel")
add_button.clicked.connect(self._add_item)
rem_button.clicked.connect(self._remove_item)
ok_button.clicked.connect(self.accept)
cancel_button.clicked.connect(self.reject)
controls_layout.addWidget(add_button)
controls_layout.addWidget(rem_button)
controls_layout.addStretch(0)
controls_layout.addWidget(ok_button)
controls_layout.addWidget(cancel_button)
vbox.addLayout(controls_layout)
def __init__(self, parent = None, logger = Logger()):
QWidgetWithLogger.__init__(self, parent, logger)
# start widget
vbox = QVBoxLayout()
vbox.setMargin(0)
vbox.setContentsMargins(0, 0, 0, 0)
# parameter action server topic selection
topic_widget = QTopicWidget(self, 'vigir_footstep_planning_msgs/GetParameterSetNamesAction', True)
vbox.addWidget(topic_widget)
# parameter set selection
self.parameter_set_selection_widget = QParameterSetSelectionWidget(self, logger)
self.parameter_set_selection_widget.param_cleared_signal.connect(self.param_cleared)
self.parameter_set_selection_widget.param_changed_signal.connect(self.param_changed)
topic_widget.topic_changed_signal.connect(self.topic_changed)
topic_widget.topic_changed_signal.connect(self.parameter_set_selection_widget.set_topic_name)
vbox.addWidget(self.parameter_set_selection_widget)
# end widget
self.setLayout(vbox)
# init widget
topic_widget.emit_topic_name()
def add_widget(self, widget):
if widget in self._embed_widgets:
qWarning('PluginHandlerXEmbedClient.add_widget() widget "%s" already added' % widget.objectName())
return
embed_widget = QX11EmbedWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(widget)
embed_widget.setLayout(layout)
# close embed widget when container is closed
# TODO necessary?
#embed_widget.containerClosed.connect(embed_widget.close)
embed_container_window_id = self._remote_container.embed_widget(os.getpid(), widget.objectName())
embed_widget.embedInto(embed_container_window_id)
signaler = WindowChangedSignaler(widget, widget)
signaler.window_icon_changed_signal.connect(self._on_embed_widget_icon_changed)
signaler.window_title_changed_signal.connect(self._on_embed_widget_title_changed)
self._embed_widgets[widget] = embed_widget, signaler
# trigger to update initial window icon and title
signaler.window_icon_changed_signal.emit(widget)
signaler.window_title_changed_signal.emit(widget)
embed_widget.show()
def __init__(self, tabwidget, parent=None):
QDockWidget.__init__(self, "Find", parent)
self.setObjectName('SearchFrame')
self.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable)
self._dockwidget = QFrame(self)
self.vbox_layout = QVBoxLayout(self._dockwidget)
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(1)
# frame with two rows for find and replace
find_replace_frame = QFrame(self)
find_replace_vbox_layout = QVBoxLayout(find_replace_frame)
find_replace_vbox_layout.setContentsMargins(0, 0, 0, 0)
find_replace_vbox_layout.setSpacing(1)
# find_replace_vbox_layout.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Expanding))
# create frame with find row
find_frame = self._create_find_frame()
find_replace_vbox_layout.addWidget(find_frame)
rplc_frame = self._create_replace_frame()
find_replace_vbox_layout.addWidget(rplc_frame)
# frame for find&replace and search results
self.vbox_layout.addWidget(find_replace_frame)
self.vbox_layout.addWidget(self._create_found_frame())
# self.vbox_layout.addStretch(2024)
self.setWidget(self._dockwidget)
# intern search parameters
self._tabwidget = tabwidget
self.current_search_text = ''
self.search_results = []
self.search_results_fileset = set()
self._search_result_index = -1
self._search_recursive = False
self._search_thread = None
def __init__(self, parent=None):
super(MatPlot2D, self).__init__(parent)
self._canvas = MatPlot2D.Canvas()
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
def __init__(self, parent=None):
super(MatPlot2D, self).__init__(parent)
self._canvas = MatPlot2D.Canvas()
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
def __init__(self):
super(Tester, self).__init__();
vlayout = QVBoxLayout();
self.testButton = QPushButton("Exactly one row of buttons");
vlayout.addWidget(self.testButton);
self.testButton.clicked.connect(self.exactlyOneRow);
self.setLayout(vlayout);
self.show();
def __init__(self, content_widget, parent=None):
QDialog.__init__(self, parent)
self.tab_widget = DetachableTabWidget(self)
layout = QVBoxLayout(self)
layout.setContentsMargins(3, 3, 3, 3)
layout.addWidget(self.tab_widget)
self.setWindowFlags(Qt.Window)
tab_index = self.tab_widget.addTab(content_widget, content_widget.name())
self.tab_widget.setCurrentIndex(tab_index)
self.tab_widget.empty_tabbar_signal.connect(self._close_if_empty)
def __init__(self, parent=None):
super(PlotWidget, self).__init__(parent)
# create widgets
self.canvas = PlotCanvas()
self.toolbar = NavigationToolbar(self.canvas, self.canvas)
self.toolbar.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
vbox = QVBoxLayout()
vbox.addWidget(self.toolbar)
vbox.addWidget(self.canvas)
self.setLayout(vbox)
def __init__(self, parent=None):
super(PlotWidget, self).__init__(parent)
# create widgets
self.canvas = PlotCanvas()
self.toolbar = NavigationToolbar(self.canvas, self.canvas)
self.toolbar.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
vbox = QVBoxLayout()
vbox.addWidget(self.toolbar)
vbox.addWidget(self.canvas)
self.setLayout(vbox)
def __init__(self, parent=None):
super(PyQtGraphDataPlot, self).__init__(parent)
self._plot_widget = PlotWidget()
self._plot_widget.setBackground((255, 255, 255))
self._plot_widget.setXRange(0, 10, padding=0)
vbox = QVBoxLayout()
vbox.addWidget(self._plot_widget)
self.setLayout(vbox)
self._color_index = 0
self._curves = {}
def __init__(self, parent=None):
super(MatDataPlot, self).__init__(parent)
self._canvas = MatDataPlot.Canvas()
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
self._color_index = 0
self._curves = {}
def __init__(self, parent = None, logger = Logger(), step_plan_topic = str()):
QWidgetWithLogger.__init__(self, parent, logger)
# start widget
vbox = QVBoxLayout()
vbox.setMargin(0)
vbox.setContentsMargins(0, 0, 0, 0)
# step plan input topic selection
if len(step_plan_topic) == 0:
step_plan_topic_widget = QTopicWidget(topic_type = 'vigir_footstep_planning_msgs/StepPlan')
step_plan_topic_widget.topic_changed_signal.connect(self._init_step_plan_subscriber)
vbox.addWidget(step_plan_topic_widget)
else:
self._init_step_plan_subscriber(step_plan_topic)
# execute action server topic selection
execute_topic_widget = QTopicWidget(topic_type = 'vigir_footstep_planning_msgs/ExecuteStepPlanAction', is_action_topic = True)
execute_topic_widget.topic_changed_signal.connect(self._init_execute_action_client)
vbox.addWidget(execute_topic_widget)
# start button part
buttons_hbox = QHBoxLayout()
buttons_hbox.setMargin(0)
# execute
self.execute_command = QPushButton("Execute (Steps: 0)")
self.execute_command.clicked.connect(self.execute_command_callback)
self.execute_command.setEnabled(False)
buttons_hbox.addWidget(self.execute_command)
# repeat
self.repeat_command = QPushButton("Repeat")
self.repeat_command.clicked.connect(self.execute_command_callback)
self.repeat_command.setEnabled(False)
buttons_hbox.addWidget(self.repeat_command)
# stop
self.stop_command = QPushButton("Stop")
self.stop_command.clicked.connect(self.stop_command_callback)
self.stop_command.setEnabled(False)
buttons_hbox.addWidget(self.stop_command)
# end button part
vbox.addLayout(buttons_hbox)
# end widget
self.setLayout(vbox)
# init widget
if len(step_plan_topic) == 0:
step_plan_topic_widget.emit_topic_name()
execute_topic_widget.emit_topic_name()
def __init__(self, parent=None):
super(MatDataPlot, self).__init__(parent)
self._canvas = MatDataPlot.Canvas()
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
self._curves = {}
self._current_vline = None
self._canvas.mpl_connect('button_release_event', self._limits_changed)
def __init__(self, parent=None):
super(MatDataPlot, self).__init__(parent)
self._canvas = MatDataPlot.Canvas()
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
self._curves = {}
self._current_vline = None
self._canvas.mpl_connect('button_release_event', self._limits_changed)
class NavViewWidget(QWidget):
def __init__(self, map_topic = '/map',
paths = ['/move_base/SBPLLatticePlanner/plan', '/move_base/TrajectoryPlannerROS/local_plan'],
polygons= ['/move_base/local_costmap/robot_footprint']):
super(NavViewWidget, self).__init__()
self._layout = QVBoxLayout()
self.setWindowTitle('Navigation Viewer')
self._nav_view = NavView(map_topic, paths, polygons)
self._layout.addWidget(self._nav_view)
self.setLayout(self._layout)
class PingGUI(Plugin):
def __init__(self, context):
super(PingGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('PingGUI')
self.msg = None
# Create a container widget and give it a layout
self._container = QWidget()
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._label = QLabel("xx ms latency")
p = self._label.palette()
p.setColor(self._label.backgroundRole(), Qt.red)
self._label.setPalette(p)
self._layout.addWidget(self._label)
self.set_bg_color(100, 100, 100)
rospy.Subscriber("/ping/delay", Float64, self.ping_cb)
context.add_widget(self._container)
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_gui)
self._update_plot_timer.start(1)
def update_gui(self):
if not self.msg:
return
msg = self.msg
# msec
# 100 -> green, 1000 -> red
# normalize within 1000 ~ 100
orig_latency = msg.data
msg_data = orig_latency
if msg.data > 1000:
msg_data = 1000
elif msg.data < 100:
msg_data = 100
ratio = (msg_data - 100) / (1000 - 100)
color_r = ratio * 255.0
color_g = (1 - ratio) * 255.0
# devnull = open(os.devnull, "w")
# with RedirectStdStreams(stdout=devnull, stderr=devnull):
self.set_bg_color(color_r, color_g, 0)
self._label.setText("%d ms latency" % (orig_latency))
def set_bg_color(self, r, g, b):
self._label.setStyleSheet("QLabel { display: block; background-color: rgba(%d, %d, %d, 255); text-align: center; font-size: 30px;}" % (r, g, b))
def ping_cb(self, msg):
self.msg = msg
def shutdown_plugin(self):
pass
def save_settings(self, plugin_settings, instance_settings):
pass
def restore_settings(self, plugin_settings, instance_settings):
pass
def __init__(self, parent=None):
super(PyQtGraphDataPlot, self).__init__(parent)
self._plot_widget = PlotWidget()
self._plot_widget.getPlotItem().addLegend()
self._plot_widget.setBackground((255, 255, 255))
self._plot_widget.setXRange(0, 10, padding=0)
vbox = QVBoxLayout()
vbox.addWidget(self._plot_widget)
self.setLayout(vbox)
self._plot_widget.getPlotItem().sigRangeChanged.connect(self.limits_changed)
self._curves = {}
self._current_vline = None
def setup_group_frame(self, group):
layout = QVBoxLayout()
# grid for buttons for named targets
grid = QGridLayout()
grid.setSpacing(1)
self.button_group = QButtonGroup(self)
row = 0
column = 0
named_targets = self.get_named_targets(group)
for target in named_targets:
button = QPushButton(target)
self.button_group.addButton(button)
grid.addWidget(button, row, column)
column += 1
if column >= self.MAX_COLUMNS:
row += 1
column = 0
self.button_group.buttonClicked.connect(self._handle_button_clicked)
# grid for show joint value and move arm buttons/text field
joint_values_grid = QGridLayout()
joint_values_grid.setSpacing(1)
button_show_joint_values = QPushButton('Current Joint Values')
button_show_joint_values.clicked[bool].connect(
self._handle_show_joint_values_clicked)
line_edit = QLineEdit()
self.text_joint_values.append(line_edit)
button_move_to = QPushButton('Move to')
button_move_to.clicked[bool].connect(self._handle_move_to_clicked)
joint_values_grid.addWidget(button_show_joint_values, 0, 1)
joint_values_grid.addWidget(line_edit, 0, 2)
joint_values_grid.addWidget(button_move_to, 0, 3)
layout.addLayout(grid)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout.addWidget(line)
layout.addLayout(joint_values_grid)
frame = QFrame()
frame.setLayout(layout)
return frame
def __init__(self, ):
super(LocalNavGUI, self).__init__()
self.setObjectName("LocalNavGUI")
self._widget = QWidget()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'localnav_gui.ui')
loadUi(ui_file, self._widget)
l = QVBoxLayout(self)
l.addWidget(self._widget)
# set ROS subscriber
#rospy.Subscriber("/SLAM/current_pose", Pose2D, self.currentPoseCallback)
rospy.Subscriber("/localnav/sensor_data", PointCloud,
self.sensorDataCallback)
rospy.Subscriber("/localnav/objects", Object, self.objectCallback)
# set UI stuff
self._widget.map.setScene(QtGui.QGraphicsScene(self))
self.viewRect = self._widget.map.rect()
self.mapHeight = self.viewRect.height()
self.mapWidth = self.viewRect.width()
self._widget.map.setSceneRect(QtCore.QRectF(self.viewRect))
self.scene = self._widget.map.scene()
# link buttons to functions
self._widget.buttonClear.clicked.connect(self.buttonClear)
self._widget.checkGrid.stateChanged.connect(self.filterGrid)
self._widget.checkAxis.stateChanged.connect(self.filterAxis)
self._widget.checkRobot.stateChanged.connect(self.filterRobot)
self._widget.checkOrientation.stateChanged.connect(
self.filterOrientation)
self._widget.checkPath.stateChanged.connect(self.filterPath)
self._widget.checkSensorData.stateChanged.connect(
self.filterSensorData)
self._widget.checkObjects.stateChanged.connect(self.filterObjects)
self._widget.checkObstacles.stateChanged.connect(self.filterObstacles)
# subscribe to signals
self.sigRedraw.connect(self.sigRedrawHandler)
# launch thread that redraws the map at a set rate
t_redraw = threading.Thread(target=self.threadRedraw)
t_redraw.daemon = True
t_redraw.start()
def __init__(self, parent=None, buffer_length=100, use_poly=True,
no_legend=False):
super(MatDataPlot3D, self).__init__(parent)
self._canvas = MatDataPlot3D.Canvas()
self._use_poly = use_poly
self._buffer_length = buffer_length
self._toolbar = NavigationToolbar(self._canvas, self._canvas)
vbox = QVBoxLayout()
vbox.addWidget(self._toolbar)
vbox.addWidget(self._canvas)
self.setLayout(vbox)
self._curves_verts = {}
self._color_index = 0
self._curves = {}
self._no_legend = no_legend
self._autoscroll = False
def __init__(self,):
super(LocalNavGUI, self).__init__()
self.setObjectName("LocalNavGUI")
self._widget = QWidget()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'localnav_gui.ui')
loadUi(ui_file, self._widget)
l = QVBoxLayout(self)
l.addWidget(self._widget)
# set ROS subscriber
#rospy.Subscriber("/SLAM/current_pose", Pose2D, self.currentPoseCallback)
rospy.Subscriber("/localnav/sensor_data", PointCloud, self.sensorDataCallback)
rospy.Subscriber("/localnav/objects", Object, self.objectCallback)
# set UI stuff
self._widget.map.setScene(QtGui.QGraphicsScene(self))
self.viewRect = self._widget.map.rect()
self.mapHeight = self.viewRect.height()
self.mapWidth = self.viewRect.width()
self._widget.map.setSceneRect(QtCore.QRectF(self.viewRect))
self.scene = self._widget.map.scene()
# link buttons to functions
self._widget.buttonClear.clicked.connect(self.buttonClear)
self._widget.checkGrid.stateChanged.connect(self.filterGrid)
self._widget.checkAxis.stateChanged.connect(self.filterAxis)
self._widget.checkRobot.stateChanged.connect(self.filterRobot)
self._widget.checkOrientation.stateChanged.connect(self.filterOrientation)
self._widget.checkPath.stateChanged.connect(self.filterPath)
self._widget.checkSensorData.stateChanged.connect(self.filterSensorData)
self._widget.checkObjects.stateChanged.connect(self.filterObjects)
self._widget.checkObstacles.stateChanged.connect(self.filterObstacles)
# subscribe to signals
self.sigRedraw.connect(self.sigRedrawHandler)
# launch thread that redraws the map at a set rate
t_redraw = threading.Thread(target=self.threadRedraw)
t_redraw.daemon = True
t_redraw.start()
def __init__(self, context):
super(BiasCalibrationDialog, self).__init__(context)
self.setObjectName('BiasCalibrationDialog')
self._widget = QWidget()
vbox = QVBoxLayout()
controller_widget = QWidget()
hbox = QHBoxLayout()
# Left to right layout
self.joint_control = JointBias(self, roslib.packages.get_pkg_dir('vigir_rqt_bias_calibration') + '/launch/joints.txt',hbox)
controller_widget.setLayout(hbox)
self.marker = Marker()
self.marker.header.frame_id = "/world"
self.marker.type = self.marker.CUBE
self.marker.action = self.marker.ADD
self.marker.scale.x = 14.0
self.marker.scale.y = 14.0
self.marker.scale.z = 0.02
self.marker.color.a = 0.25
self.marker.color.r = 1.0
self.marker.color.g = 1.0
self.marker.color.b = 0.0
#self.marker.points = [[0.0, 0.0, 0.0], [7.0, -4.0, 0.0], [7.0, 4.0, 0.0]]
self.marker.pose.orientation.w = 1.0
self.marker.pose.position.x = 0.0
self.marker.pose.position.y = 0.0
self.marker.pose.position.z = 0.0
self.bias_pub = rospy.Publisher('/flor/controller/atlas_biases', JointState, queue_size=10)
self.flor_marker_pub = rospy.Publisher('/flor_plane_marker', Marker, queue_size=10)
self.feet_state_sub = rospy.Subscriber('/atlas/atlas_sim_interface_state', AtlasSimInterfaceState, self.stateCallbackFnc)
vbox.addWidget(controller_widget)
self.save_button = QPushButton("Save Biases")
self.save_button.pressed.connect(self.on_savePressed)
vbox.addWidget(self.save_button)
self._widget.setLayout(vbox)
context.add_widget(self._widget)
def __init__(self, masteruri, cfg, ns, nodes, parent=None):
QFrame.__init__(self, parent)
self._masteruri = masteruri
self._nodes = {cfg: {ns: nodes}}
frame_layout = QVBoxLayout(self)
frame_layout.setContentsMargins(0, 0, 0, 0)
# create frame for warning label
self.warning_frame = warning_frame = QFrame(self)
warning_layout = QHBoxLayout(warning_frame)
warning_layout.setContentsMargins(0, 0, 0, 0)
warning_layout.addItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
self.warning_label = QLabel()
icon = nm.settings().icon('crystal_clear_warning.png')
self.warning_label.setPixmap(icon.pixmap(QSize(40, 40)))
self.warning_label.setToolTip(
'Multiple configuration for same node found!\nA first one will be selected for the start a node!'
)
warning_layout.addWidget(self.warning_label)
warning_layout.addItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
frame_layout.addItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
frame_layout.addWidget(warning_frame)
# create frame for start/stop buttons
buttons_frame = QFrame()
buttons_layout = QHBoxLayout(buttons_frame)
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_layout.addItem(QSpacerItem(20, 20))
self.on_button = QPushButton()
self.on_button.setFlat(False)
self.on_button.setText("On")
self.on_button.clicked.connect(self.on_on_clicked)
buttons_layout.addWidget(self.on_button)
self.off_button = QPushButton()
self.off_button.setFlat(True)
self.off_button.setText("Off")
self.off_button.clicked.connect(self.on_off_clicked)
buttons_layout.addWidget(self.off_button)
buttons_layout.addItem(QSpacerItem(20, 20))
frame_layout.addWidget(buttons_frame)
frame_layout.addItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
self.warning_frame.setVisible(False)
def __init__(self, context):
super(StableStepDialog, self).__init__(context)
self.setObjectName('StableStepDialog')
self.bdi_state_msg = AtlasSimInterfaceState()
self.footstep_plan = rospy.Publisher('/flor/controller/footstep_plan',AtlasFootstepPlan, None, False, True, None, queue_size=10)
self.bdi_state_sub = rospy.Subscriber("/atlas/atlas_sim_interface_state", AtlasSimInterfaceState, self.simStateCallback)
self._widget = QWidget()
vbox = QVBoxLayout()
apply_command = QPushButton("Re-Center Steps")
apply_command.clicked.connect(self.apply_command_callback)
vbox.addWidget(apply_command)
vbox.addStretch(1)
self._widget.setLayout(vbox)
context.add_widget(self._widget)
class CameraViewWidget(QWidget):
def __init__(self, camera_topic='/image_raw', name='camera'):
super(CameraViewWidget,self).__init__()
self._layout = QVBoxLayout()
self.name = name
self._colors = [(238, 34, 116), (68, 134, 252), (236, 228, 46), (102, 224, 18), (242, 156, 6), (240, 64, 10), (196, 30, 250)]
self.setWindowTitle('Camera \''+name+'\' Viewer')
self._cam_view = CameraView(camera_topic)
self._layout.addWidget(self._cam_view)
self.setLayout(self._layout)
def close(self):
if self._cam_view:
self._cam_view.close()
def __init__(self, parent=None, logger=Logger()):
QWidgetWithLogger.__init__(self, parent, logger)
# start widget
vbox = QVBoxLayout()
vbox.setMargin(0)
vbox.setContentsMargins(0, 0, 0, 0)
# add layout which is dynamically filled
self.parameter_tree_widget = QParameterTreeWidget(logger=self.logger)
vbox.addWidget(self.parameter_tree_widget)
# button panel
vbox_commands = QVBoxLayout()
hbox = QHBoxLayout()
# upload topic
send_parameter_topic_widget = QTopicWidget(self, 'vigir_footstep_planning_msgs/SetParameterSetAction', True)
send_parameter_topic_widget.topic_changed_signal.connect(self._init_upload_paramater_set_client)
hbox.addWidget(send_parameter_topic_widget)
# upload command
self.upload_command = QPushButton("Upload")
self.upload_command.clicked.connect(self.upload_parameters)
hbox.addWidget(self.upload_command)
vbox_commands.addLayout(hbox)
# reload command
self.reload_command = QPushButton("Reload")
self.reload_command.clicked.connect(self.reload_parameters)
vbox_commands.addWidget(self.reload_command)
# add button panel
vbox.addLayout(vbox_commands)
# end widget
self.setLayout(vbox)
# init
self.clear()
send_parameter_topic_widget.emit_topic_name()
class CameraViewWidget(QWidget):
def __init__(self, camera_topic='/image_raw', name='camera'):
super(CameraViewWidget, self).__init__()
self._layout = QVBoxLayout()
self.name = name
self._colors = [(238, 34, 116), (68, 134, 252), (236, 228, 46),
(102, 224, 18), (242, 156, 6), (240, 64, 10),
(196, 30, 250)]
self.setWindowTitle('Camera \'' + name + '\' Viewer')
self._cam_view = CameraView(camera_topic)
self._layout.addWidget(self._cam_view)
self.setLayout(self._layout)
def close(self):
if self._cam_view:
self._cam_view.close()
def __init__(self, topic):
super(RobotMonitor, self).__init__()
self.setObjectName('Robot Monitor')
self.top_items = []
layout = QVBoxLayout()
self.err = QTreeWidget()
self.err.setHeaderLabel("Errors")
self.warn = QTreeWidget()
self.warn.setHeaderLabel("Warnings")
self.sig_clear.connect(self.clear)
self.sig_err.connect(self.disp_err)
self.sig_warn.connect(self.disp_warn)
self.comp = QTreeWidget()
self.comp.setHeaderLabel("All")
self.comp.itemDoubleClicked.connect(self.tree_clicked)
self.time = TimelineWidget(self)
layout.addWidget(self.err)
layout.addWidget(self.warn)
layout.addWidget(self.comp, 1)
layout.addWidget(self.time, 0)
self.setLayout(layout)
self.paused = False
self.topic = topic
self.sub = rospy.Subscriber(self.topic, DiagnosticArray, self.cb)
self.setWindowTitle('Robot Monitor')
def __init__(self, context):
super(MotionEditorPlugin, self).__init__(context)
self.setObjectName('MotionEditorPlugin')
config_loader = RobotConfigLoader()
try:
robot_config_name = rospy.get_param('/motion_editor/robot_config')
except KeyError:
rospy.logwarn('Could not find robot config param in /motion_editor/robot_config. Using default config for '
'Thor Mang.')
robot_config_name = 'thor'
config_loader.load_xml_by_name(robot_config_name + '_config.xml')
motion_publishers = {}
for target in config_loader.targets:
motion_publishers[target.name] = MotionPublisher(config_loader.robot_config, target.joint_state_topic, target.publisher_prefix)
input_output_selector = InputOutputSelectorWidget(motion_publishers)
self._motion_editor = MotionEditorWidget(input_output_selector, config_loader.robot_config)
position_editor = PositionEditorWidget(input_output_selector, config_loader.robot_config)
position_editor.position_list_updated.connect(self._motion_editor.update_positions_lists)
position_editor.position_list_updated.emit(position_editor._position_data)
self._motion_editor.position_renamed.connect(position_editor.on_position_renamed)
layout = QVBoxLayout()
layout.addWidget(input_output_selector)
layout.addWidget(position_editor)
layout.addWidget(self._motion_editor)
self._widget = QWidget()
self._widget.setLayout(layout)
context.add_widget(self._widget)
def _update_client_tab(self):
print('[conductor graph]: _update_client_tab')
self.pre_selected_client_name = self.cur_selected_client_name
self._widget.tabWidget.clear()
for k in self._graph.concert_clients.values():
# Only pull in information from connected or connectable clients
if k.state not in [
concert_msgs.ConcertClientState.AVAILABLE,
concert_msgs.ConcertClientState.MISSING,
concert_msgs.ConcertClientState.UNINVITED
]:
continue
main_widget = QWidget()
ver_layout = QVBoxLayout(main_widget)
ver_layout.setContentsMargins(9, 9, 9, 9)
ver_layout.setSizeConstraint(ver_layout.SetDefaultConstraint)
#button layout
sub_widget = QWidget()
sub_widget.setAccessibleName('sub_widget')
ver_layout.addWidget(sub_widget)
#client information layout
context_label = QLabel()
context_label.setText("Client information")
ver_layout.addWidget(context_label)
app_context_widget = QPlainTextEdit()
app_context_widget.setObjectName(k.concert_alias + '_' +
'app_context_widget')
app_context_widget.setAccessibleName('app_context_widget')
app_context_widget.appendHtml(k.get_rapp_context())
app_context_widget.setReadOnly(True)
cursor = app_context_widget.textCursor()
cursor.movePosition(QTextCursor.Start, QTextCursor.MoveAnchor, 0)
app_context_widget.setTextCursor(cursor)
ver_layout.addWidget(app_context_widget)
# new icon
path = ""
if k.is_new:
# This only changes when the concert client changes topic publishes anew
path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"../../resources/images/new.gif")
#add tab
self._widget.tabWidget.addTab(main_widget, QIcon(path),
k.concert_alias)
#set previous selected tab
for k in range(self._widget.tabWidget.count()):
tab_text = self._widget.tabWidget.tabText(k)
if tab_text == self.pre_selected_client_name:
self._widget.tabWidget.setCurrentIndex(k)
def __init__(self, masteruri, cfg, ns, nodes, parent=None):
QFrame.__init__(self, parent)
self._masteruri = masteruri
self._nodes = {cfg: {ns: nodes}}
frame_layout = QVBoxLayout(self)
frame_layout.setContentsMargins(0, 0, 0, 0)
# create frame for warning label
self.warning_frame = warning_frame = QFrame(self)
warning_layout = QHBoxLayout(warning_frame)
warning_layout.setContentsMargins(0, 0, 0, 0)
warning_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
self.warning_label = QLabel()
icon = QIcon(':/icons/crystal_clear_warning.png')
self.warning_label.setPixmap(icon.pixmap(QSize(40, 40)))
self.warning_label.setToolTip('Multiple configuration for same node found!\nA first one will be selected for the start a node!')
warning_layout.addWidget(self.warning_label)
warning_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
frame_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
frame_layout.addWidget(warning_frame)
# create frame for start/stop buttons
buttons_frame = QFrame()
buttons_layout = QHBoxLayout(buttons_frame)
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_layout.addItem(QSpacerItem(20, 20))
self.on_button = QPushButton()
self.on_button.setFlat(False)
self.on_button.setText("On")
self.on_button.clicked.connect(self.on_on_clicked)
buttons_layout.addWidget(self.on_button)
self.off_button = QPushButton()
self.off_button.setFlat(True)
self.off_button.setText("Off")
self.off_button.clicked.connect(self.on_off_clicked)
buttons_layout.addWidget(self.off_button)
buttons_layout.addItem(QSpacerItem(20, 20))
frame_layout.addWidget(buttons_frame)
frame_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))
self.warning_frame.setVisible(False)
def __init__(self, context):
super(MoveitCommanderWidget, self).__init__()
self.setObjectName('MoveitCommanderWidget')
self.groups = self.get_groups()
self.commanders = [
moveit_commander.MoveGroupCommander(group) for group in self.groups
]
# list of QLineEdit fields used to display joint values
self.text_joint_values = []
self.MAX_COLUMNS = 4
self.tab_widget = QTabWidget()
for g in self.groups:
frame = self.setup_group_frame(g)
self.tab_widget.addTab(frame, g)
widget_layout = QVBoxLayout()
widget_layout.addWidget(self.tab_widget)
self.setLayout(widget_layout)
def add_toolbar(self, toolbar):
if toolbar in self._embed_widgets:
qWarning('PluginHandlerXEmbedClient.add_toolbar() toolbar "%s" already added' % toolbar.objectName())
return
embed_widget = QX11EmbedWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(toolbar)
embed_widget.setLayout(layout)
# close embed widget when container is closed
# TODO necessary?
#embed_widget.containerClosed.connect(embed_widget.close)
def foo():
print('embed_widget.containerClosed')
embed_widget.containerClosed.connect(foo)
embed_container_window_id = self._remote_container.embed_toolbar(os.getpid(), toolbar.objectName())
embed_widget.embedInto(embed_container_window_id)
self._embed_widgets[toolbar] = embed_widget, None
embed_widget.show()
def __init__(self, context):
super(ParameterEditorWidget, self).__init__()
# start widget
widget = context
vbox = QVBoxLayout()
error_status_widget = QErrorStatusWidget()
self.logger = Logger(error_status_widget)
# parameter set selection
self.parameter_set_widget = QParameterSetWidget(logger=self.logger)
add_widget_with_frame(vbox, self.parameter_set_widget, "Parameter Set:")
# start horizontal splitter
vsplitter = QSplitter()
vsplitter.setOrientation(Qt.Vertical)
vsplitter.setChildrenCollapsible(False)
# parameter set editor
parameter_editor_widget = QParameterEditorWidget(logger=self.logger)
add_widget_with_frame(vsplitter, parameter_editor_widget, "Editor:")
# add error status widget
add_widget_with_frame(vsplitter, error_status_widget, "Status:")
# end horizontal splitter
vbox.addWidget(vsplitter)
# end widget
widget.setLayout(vbox)
#context.add_widget(widget)
# init parameter editor
self.parameter_set_widget.topic_changed_signal.connect(parameter_editor_widget.set_get_parameter_set_topic_name)
self.parameter_set_widget.param_changed_signal.connect(parameter_editor_widget.load_parameters)
self.parameter_set_widget.param_cleared_signal.connect(parameter_editor_widget.clear)
class DataDialog(QWidget):
TOPIC_NAME = 'chatter'
MSG_CLASS = Float32
def __init__(self):
super(DataDialog, self).__init__()
rp = rospkg.RosPack()
uiFile = os.path.join(rp.get_path('my_topic_viewer'), 'resource', 'TopicViewer.ui')
loadUi(uiFile, self)
self._displayedData = None
self._displayedName = None
self._groupBox = QGroupBox()
self._layout = QFormLayout()
self._mainLayout = QVBoxLayout();
self._mainLayout.addWidget(self._groupBox)
# self.setLayout(self._mainLayout);
def setDisplayedData(self, data, name):
if isinstance(data, dict):
self.displayData(data)
else:
dictData = {}
if name is None:
dictData['unknown'] = data
elif isinstance(data, list):
dictData = dict(zip(name, data))
else:
dictData[name] = data
self.displayData(dictData)
def displayData(self, dictData):
for key in dictData.keys():
self._layout.addRow(QLabel(key+': '), QLineEdit(str(dictData[key])))
def __init__(self, main, fileName, main_hbox):
self.main = main
self.chain = []
self.poses = []
self.chain_name = ""
frame = QFrame()
frame.setFrameShape(QFrame.StyledPanel);
frame.setFrameShadow(QFrame.Raised);
vbox = QVBoxLayout()
label = QLabel()
vbox.addWidget(label);
self.load_file(fileName, vbox)
self.trajectoryPublisher = rospy.Publisher('/trajectory_controllers/'+self.chain_name+'_traj_controller/trajectory' ,JointTrajectory, queue_size=10)
self.positionPublisher = rospy.Publisher('/trajectory_controllers/'+self.chain_name+'_traj_controller/joint_states',JointState, queue_size=10)
self.ghostPublisher = rospy.Publisher('/flor/ghost/set_joint_states',JointState, queue_size=10)
label.setText(self.chain_name)
vbox.addStretch(1)
frame.setLayout(vbox)
main_hbox.addWidget(frame)
def __init__(self, caller, jointstate, parent=None, stored_topic=None):
super(JointStateGroup, self).__init__(parent)
ti = TopicInfo()
# create a new group
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'iop_rqt_velocity_joint_group.ui')
loadUi(ui_file, self)
group_layout = QVBoxLayout(self.frame)
group_layout.setContentsMargins(0, 0, 0, 0)
group_layout.setSpacing(0)
self._cmd_type = Float64MultiArray
if len(jointstate.name) == 1:
self._cmd_type = Float64
ti.fill_subscribed_topics(self.comboBox_cmdTopic, self._cmd_type._type, stored_topic)
for joint_name in jointstate.name:
joint_frame = QFrame()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'iop_rqt_velocity_joint.ui')
loadUi(ui_file, joint_frame)
joint_frame.setObjectName(joint_name)
joint_frame.labelJointName.setText(joint_name)
joint_frame.lineEditCurrentValue.setText('0.0')
joint_frame.doubleSpinBoxNewValue.setValue(0.0)
joint_frame.layout().setContentsMargins(0, 0, 0, 0)
joint_frame.layout().setSpacing(0)
group_layout.addWidget(joint_frame)
# self._widget.layout().insertWidget(self._widget.layout().count() - 1, group_frame)
# self._jointgroups[caller] = group_frame
self.setObjectName(caller)
self._caller = caller
self._jointstate = jointstate
self._topic_command = self.comboBox_cmdTopic.currentText()
self.pushButtonSend.clicked.connect(self.on_clicked_send)
self.pushButtonSendZero.clicked.connect(self.on_clicked_send_zero)
self.comboBox_cmdTopic.activated.connect(self.on_activated_topic)
self._cmd_publisher = None
if self._cmd_type and self._topic_command:
self._cmd_publisher = rospy.Publisher(self._topic_command, self._cmd_type, queue_size=1)
def __init__(self, parent=None):
super(VisualizerWidget, self).__init__(parent)
self.setWindowTitle('Graph Profiler Visualizer')
vbox = QVBoxLayout()
self.setLayout(vbox)
toolbar_layout = QHBoxLayout()
refresh_button = QPushButton()
refresh_button.setIcon(QIcon.fromTheme('view-refresh'))
auto_refresh_checkbox = QCheckBox("Auto Refresh")
hide_disconnected_topics = QCheckBox("Hide Disconnected Topics")
topic_blacklist_button = QPushButton("Topic Blacklist")
node_blacklist_button = QPushButton("Node Blacklist")
refresh_button.clicked.connect(self._refresh)
topic_blacklist_button.clicked.connect(self._edit_topic_blacklist)
node_blacklist_button.clicked.connect(self._edit_node_blacklist)
auto_refresh_checkbox.setCheckState(2)
auto_refresh_checkbox.stateChanged.connect(self._autorefresh_changed)
hide_disconnected_topics.setCheckState(2)
hide_disconnected_topics.stateChanged.connect(self._hidedisconnectedtopics_changed)
toolbar_layout.addWidget(refresh_button)
toolbar_layout.addWidget(auto_refresh_checkbox)
toolbar_layout.addStretch(0)
toolbar_layout.addWidget(hide_disconnected_topics)
toolbar_layout.addWidget(topic_blacklist_button)
toolbar_layout.addWidget(node_blacklist_button)
vbox.addLayout(toolbar_layout)
# Initialize the Visualizer
self._view = qt_view.QtView()
self._adapter = rosprofiler_adapter.ROSProfileAdapter(self._view)
self._adapter.set_topic_quiet_list(TOPIC_BLACKLIST)
self._adapter.set_node_quiet_list(NODE_BLACKLIST)
vbox.addWidget(self._view)
def __init__(self, parent, fileName, top_widget_layout):
self.controllers = []
self.parent = parent
self.loadFile(fileName)
print "Initialize controllers..."
for controller in self.controllers:
frame = QFrame()
frame.setFrameShape(QFrame.StyledPanel);
frame.setFrameShadow(QFrame.Raised);
vbox = QVBoxLayout()
label = QLabel()
label.setText(controller.label)
vbox.addWidget(label);
print controller.name
for joint in controller.joints:
label = QLabel()
label.setText(joint.name)
vbox.addWidget(label);
#Add input for setting the biases
widget = QWidget()
hbox = QHBoxLayout()
hbox.addWidget(joint.sensor_bias_spinbox)
hbox.addWidget(joint.control_bias_spinbox)
hbox.addWidget(joint.gearing_bias_spinbox)
widget.setLayout(hbox)
vbox.addWidget(widget)
label = QLabel()
label.setText(" Sensor Control Gearing")
vbox.addWidget(label);
vbox.addStretch()
frame.setLayout(vbox)
top_widget_layout.addWidget(frame)
print "Done loading controllers"
class NodeSelection(QWidget):
def __init__(self, parent):
super(NodeSelection, self).__init__()
self.parent_widget = parent
self.selected_nodes = []
self.setWindowTitle("Select the nodes you want to record")
self.resize(500, 700)
self.area = QScrollArea(self)
self.main_widget = QWidget(self.area)
self.ok_button = QPushButton("Done", self)
self.ok_button.clicked.connect(self.onButtonClicked)
self.ok_button.setEnabled(False)
self.main_vlayout = QVBoxLayout(self)
self.main_vlayout.addWidget(self.area)
self.main_vlayout.addWidget(self.ok_button)
self.setLayout(self.main_vlayout)
self.selection_vlayout = QVBoxLayout(self)
self.node_list = rosnode.get_node_names()
self.node_list.sort()
for node in self.node_list:
self.addCheckBox(node)
self.main_widget.setLayout(self.selection_vlayout)
self.show()
def addCheckBox(self, node):
item = QCheckBox(node, self)
item.stateChanged.connect(lambda x: self.updateNode(x, node))
self.selection_vlayout.addWidget(item)
def updateNode(self, state, node):
if state == Qt.Checked:
self.selected_nodes.append(node)
else:
self.selected_nodes.remove(node)
if len(self.selected_nodes) > 0:
self.ok_button.setEnabled(True)
else:
self.ok_button.setEnabled(False)
def onButtonClicked(self):
master = rosgraph.Master('rqt_bag_recorder')
state = master.getSystemState()
subs = [
t for t, l in state[1] if len([
node_name
for node_name in self.selected_nodes if node_name in l
]) > 0
]
for topic in subs:
self.parent_widget.changeTopicCheckState(topic, Qt.Checked)
self.parent_widget.updateList(Qt.Checked, topic)
self.close()
class TriangleGUI(Plugin):
def __init__(self, context):
super(TriangleGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('TriangleGUI')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q",
"--quiet",
action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
self._toolbar = QToolBar()
self._toolbar.addWidget(QLabel('Triangle'))
# Create a container widget and give it a layout
self._container = QWidget()
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._layout.addWidget(self._toolbar)
# Add a button for killing nodes
self._go_button = QPushButton('Go')
self._go_button.clicked.connect(self._go)
self._layout.addWidget(self._go_button)
self._clear_button = QPushButton('Clear')
self._clear_button.clicked.connect(self._clear)
self._layout.addWidget(self._clear_button)
# self._step_run_button.setStyleSheet('QPushButton {color: black}')
context.add_widget(self._container)
def _go(self):
go = rospy.ServiceProxy('/triangle_screenpoint/go', Empty)
go()
def _clear(self):
clear = rospy.ServiceProxy('/triangle_screenpoint/cancel', Empty)
clear()
def shutdown_plugin(self):
pass
def save_settings(self, plugin_settings, instance_settings):
pass
def restore_settings(self, plugin_settings, instance_settings):
pass
class EusGUI(Plugin):
def __init__(self, context):
super(EusGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('EusGUI')
self.msg = None
# Create a container widget and give it a layout
self._toolbar = QToolBar()
self._toolbar.addWidget(QLabel('EusGUI'))
self._container = QWidget()
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._layout.addWidget(self._toolbar)
self._prev_button = QPushButton('PREV')
self._prev_button.clicked.connect(self._prev_cb)
self._layout.addWidget(self._prev_button)
self._refresh_button = QPushButton('DO IT AGAIN')
self._refresh_button.clicked.connect(self._refresh_cb)
self._layout.addWidget(self._refresh_button)
self._next_button = QPushButton('NEXT')
self._next_button.clicked.connect(self._next_cb)
self._layout.addWidget(self._next_button)
context.add_widget(self._container)
def _prev_cb(self):
func = rospy.ServiceProxy('prev', Empty)
func()
def _next_cb(self):
func = rospy.ServiceProxy('next', Empty)
func()
def _refresh_cb(self):
func = rospy.ServiceProxy('refresh', Empty)
func()
def shutdown_plugin(self):
pass
def save_settings(self, plugin_settings, instance_settings):
pass
def restore_settings(self, plugin_settings, instance_settings):
pass
class TriangleGUI(Plugin):
def __init__(self, context):
super(TriangleGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('TriangleGUI')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
self._toolbar = QToolBar()
self._toolbar.addWidget(QLabel('Triangle'))
# Create a container widget and give it a layout
self._container = QWidget()
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._layout.addWidget(self._toolbar)
# Add a button for killing nodes
self._go_button = QPushButton('Go')
self._go_button.clicked.connect(self._go)
self._layout.addWidget(self._go_button)
self._clear_button = QPushButton('Clear')
self._clear_button.clicked.connect(self._clear)
self._layout.addWidget(self._clear_button)
# self._step_run_button.setStyleSheet('QPushButton {color: black}')
context.add_widget(self._container)
def _go(self):
go = rospy.ServiceProxy('/triangle_screenpoint/go', Empty)
go()
def _clear(self):
clear = rospy.ServiceProxy('/triangle_screenpoint/cancel', Empty)
clear()
def shutdown_plugin(self):
pass
def save_settings(self, plugin_settings, instance_settings):
pass
def restore_settings(self, plugin_settings, instance_settings):
pass
class Top(Plugin):
NODE_FIELDS = [ 'pid', 'get_cpu_percent', 'get_memory_percent', 'get_num_threads']
OUT_FIELDS = ['node_name', 'pid', 'cpu_percent', 'memory_percent', 'num_threads' ]
FORMAT_STRS = ['%s', '%s', '%0.2f', '%0.2f', '%s' ]
NODE_LABELS = ['Node', 'PID', 'CPU %', 'Mem %', 'Num Threads' ]
SORT_TYPE = [str, str, float, float, float ]
TOOLTIPS = {
0: ('cmdline', lambda x: '\n'.join(textwrap.wrap(' '.join(x)))),
3: ('memory_info', lambda x: ('Resident: %0.2f MiB, Virtual: %0.2f MiB' % (x[0]/2**20, x[1]/2**20)))
}
_node_info = NodeInfo()
name_filter = re.compile('')
def __init__(self, context):
super(Top, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('Top')
# Process standalone plugin command-line arguments
from argparse import ArgumentParser
parser = ArgumentParser()
# Add argument(s) to the parser.
parser.add_argument("-q", "--quiet", action="store_true",
dest="quiet",
help="Put plugin in silent mode")
args, unknowns = parser.parse_known_args(context.argv())
# if not args.quiet:
# print 'arguments: ', args
# print 'unknowns: ', unknowns
self._selected_node = ''
self._selected_node_lock = RLock()
# Setup the toolbar
self._toolbar = QToolBar()
self._filter_box = QLineEdit()
self._regex_box = QCheckBox()
self._regex_box.setText('regex')
self._toolbar.addWidget(QLabel('Filter'))
self._toolbar.addWidget(self._filter_box)
self._toolbar.addWidget(self._regex_box)
self._filter_box.returnPressed.connect(self.update_filter)
self._regex_box.stateChanged.connect(self.update_filter)
# Create a container widget and give it a layout
self._container = QWidget()
self._container.setWindowTitle('Process Monitor')
self._layout = QVBoxLayout()
self._container.setLayout(self._layout)
self._layout.addWidget(self._toolbar)
# Create the table widget
self._table_widget = QTreeWidget()
self._table_widget.setObjectName('TopTable')
self._table_widget.setColumnCount(len(self.NODE_LABELS))
self._table_widget.setHeaderLabels(self.NODE_LABELS)
self._table_widget.itemClicked.connect(self._tableItemClicked)
self._table_widget.setSortingEnabled(True)
self._table_widget.setAlternatingRowColors(True)
self._layout.addWidget(self._table_widget)
context.add_widget(self._container)
# Add a button for killing nodes
self._kill_button = QPushButton('Kill Node')
self._layout.addWidget(self._kill_button)
self._kill_button.clicked.connect(self._kill_node)
# Update twice since the first cpu% lookup will always return 0
self.update_table()
self.update_table()
self._table_widget.resizeColumnToContents(0)
# Start a timer to trigger updates
self._update_timer = QTimer()
self._update_timer.setInterval(1000)
self._update_timer.timeout.connect(self.update_table)
self._update_timer.start()
def _tableItemClicked(self, item, column):
with self._selected_node_lock:
self._selected_node = item.text(0)
def update_filter(self, *args):
if self._regex_box.isChecked():
expr = self._filter_box.text()
else:
expr = re.escape(self._filter_box.text())
self.name_filter = re.compile(expr)
self.update_table()
def _kill_node(self):
self._node_info.kill_node(self._selected_node)
def update_one_item(self, row, info):
twi = TopWidgetItem()
for col, field in enumerate(self.OUT_FIELDS):
val = info[field]
twi.setText(col, self.FORMAT_STRS[col] % val)
self._table_widget.insertTopLevelItem(row, twi)
for col, (key, func) in self.TOOLTIPS.iteritems():
twi.setToolTip(col, func(info[key]))
with self._selected_node_lock:
if twi.text(0) == self._selected_node:
twi.setSelected(True)
self._table_widget.setItemHidden(twi, len(self.name_filter.findall(info['node_name'])) == 0)
def update_table(self):
self._table_widget.clear()
infos = self._node_info.get_all_node_fields(self.NODE_FIELDS)
for nx, info in enumerate(infos):
self.update_one_item(nx, info)
def shutdown_plugin(self):
self._update_timer.stop()
def save_settings(self, plugin_settings, instance_settings):
instance_settings.set_value('filter_text', self._filter_box.text())
instance_settings.set_value('is_regex', int(self._regex_box.checkState()))
def restore_settings(self, plugin_settings, instance_settings):
self._filter_box.setText(instance_settings.value('filter_text'))
is_regex_int = instance_settings.value('is_regex')
if is_regex_int:
self._regex_box.setCheckState(Qt.CheckState(is_regex_int))
else:
self._regex_box.setCheckState(Qt.CheckState(0))
self.update_filter()
class QuestionDialogPlugin(Plugin):
def __init__(self, context):
super(QuestionDialogPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('QuestionDialogPlugin')
# Create QWidget
self._widget = QWidget()
self._widget.setFont(QFont("Times", 14, QFont.Bold))
self._layout = QVBoxLayout(self._widget)
self._text_browser = QTextBrowser(self._widget)
self._layout.addWidget(self._text_browser)
self._button_layout = QHBoxLayout()
self._layout.addLayout(self._button_layout)
# layout = QVBoxLayout(self._widget)
# layout.addWidget(self.button)
self._widget.setObjectName('QuestionDialogPluginUI')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
context.add_widget(self._widget)
# Setup service provider
self.service = rospy.Service('question_dialog', QuestionDialog,
self.service_callback)
self.response_ready = False
self.response = None
self.buttons = []
self.text_label = None
self.text_input = None
self.connect(self._widget, SIGNAL("update"), self.update)
self.connect(self._widget, SIGNAL("timeout"), self.timeout)
def shutdown_plugin(self):
self.service.shutdown()
def service_callback(self, req):
self.response_ready = False
self.request = req
self._widget.emit(SIGNAL("update"))
# Start timer against wall clock here instead of the ros clock.
start_time = time.time()
while not self.response_ready:
if req.timeout != QuestionDialogRequest.NO_TIMEOUT:
current_time = time.time()
if current_time - start_time > req.timeout:
self._widget.emit(SIGNAL("timeout"))
return QuestionDialogResponse(
QuestionDialogRequest.TIMED_OUT, "")
time.sleep(0.2)
return self.response
def update(self):
self.clean()
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))
self._button_layout.addWidget(button)
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)
self.text_input = QLineEdit(self._widget)
self.text_input.editingFinished.connect(self.handle_text)
self._button_layout.addWidget(self.text_input)
def timeout(self):
self._text_browser.setText("Oh no! The request timed out.")
self.clean()
def clean(self):
while self._button_layout.count():
item = self._button_layout.takeAt(0)
item.widget().deleteLater()
self.buttons = []
self.text_input = None
self.text_label = None
def handle_button(self, index):
self.response = QuestionDialogResponse(index, "")
self.clean()
self.response_ready = True
def handle_text(self):
self.response = QuestionDialogResponse(
QuestionDialogRequest.TEXT_RESPONSE,
self.text_input.text())
self.clean()
self.response_ready = True
def save_settings(self, plugin_settings, instance_settings):
# TODO save intrinsic configuration, usually using:
# instance_settings.set_value(k, v)
pass
def restore_settings(self, plugin_settings, instance_settings):
# TODO restore intrinsic configuration, usually using:
# v = instance_settings.value(k)
pass
