def condensed_layout(self):
'''Condense the information in the table if it is too long'''
self.table_widget.setRowCount(0)
self.file = [x for x in self.file if x]
self.table_widget.setRowCount(len(self.file))
self.table_widget.setColumnCount(4)
j = 0
for i in self.file:
if not i:
continue
i = i.replace(":", ";", 2)
i = i.replace("[", ":[", 2)
i = i.replace("]", "]:", 2)
i = i.split(':', 5)
i = list(filter(None, i))
if len(i) != 4:
self.table_widget.setItem(j, 0, QTableWidgetItem(""))
self.table_widget.setItem(j, 1, QTableWidgetItem(""))
self.table_widget.setItem(j, 2, QTableWidgetItem(""))
self.table_widget.setItem(j, 3, QTableWidgetItem(" ".join(i)))
else:
ros_type = QTableWidgetItem(i[0])
item = QTableWidgetItem(i[1])
if i[1] == "[ERROR]":
item.setForeground(QColor(255, 0, 0))
ros_type.setForeground(QColor(255, 0, 0))
elif i[1] == "[WARNING]":
item.setForeground(QColor(218, 165, 32))
ros_type.setForeground(QColor(218, 165, 32))
self.table_widget.setItem(j, 0, QTableWidgetItem(ros_type))
self.table_widget.setItem(j, 1, item)
self.table_widget.setItem(
j, 2, QTableWidgetItem(i[2].replace(";", ":")))
self.table_widget.setItem(j, 3, QTableWidgetItem(i[3][:500]))
if len(i[3]) > 499:
self.table_widget.setItem(
j, 3, QTableWidgetItem(i[3][:500] + "..."))
j += 1
self.table_widget.setHorizontalHeaderLabels(
["Message Type", "Priority", "Time", "Message"])
header = self.table_widget.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
header.setSectionResizeMode(3, QHeaderView.Stretch)
self.table_widget.resizeRowsToContents()
def get_cluster_node(self, node):
# let pydot imitate pygraphviz api
attr = {}
for name in node.get_attributes().iterkeys():
value = get_unquoted(node, name)
attr[name] = value
obj_dic = node.__getattribute__("obj_dict")
for name in obj_dic:
if name not in ['nodes', 'attributes', 'parent_graph'
] and obj_dic[name] is not None:
attr[name] = get_unquoted(obj_dic, name)
elif name == 'nodes':
for key in obj_dic['nodes']['graph'][0]['attributes']:
attr[key] = get_unquoted(
obj_dic['nodes']['graph'][0]['attributes'], key)
node.attr = attr
name = None
if 'label' in node.attr:
name = node.attr['label']
elif 'name' in node.attr:
name = node.attr['name']
else:
print("Error, no label defined for node with attr: %s" % node.attr)
return None
if name is None:
# happens on Lucid pygraphviz version
print(
"Error, label is None for node %s, pygraphviz version may be too old."
% node)
bb_width = node.attr['width']
bb_height = node.attr['height']
bounding_box = QRectF(0, 0,
POINTS_PER_INCH * float(bb_width) - 1.0,
POINTS_PER_INCH * float(bb_height) - 1.0)
# print bounding_box
pos = (0, 0)
if 'pos' in node.attr:
pos = node.attr['pos'].split(',')
bounding_box.moveCenter(QPointF(float(pos[0]), -float(pos[1])))
label_pos = QPointF(bounding_box.center().x(),
bounding_box.top() + LABEL_HEIGHT / 2)
color = QColor(node.attr['color']) if 'color' in node.attr else None
url = node.attr['URL'] if 'URL' in node.attr else 'N/A'
label = node.attr['label'] if 'label' in node.attr else name
graph_node_item = self._factory.create_node(bounding_box=bounding_box,
shape='box',
label=label,
label_pos=label_pos,
url=url,
cluster=True)
return graph_node_item
def add_curve(self, curve_id, curve_name, data_x, data_y):
data_x = collections.deque(data_x)
data_y = collections.deque(data_y)
color = QColor(self._colors[self._color_index % len(self._colors)])
self._color_index += 1
plot = self._canvas.axes.plot(data_x, data_y, label=curve_name, linewidth=1, picker=5, color=color.name())[0]
self._curves[curve_id] = (data_x, data_y, plot)
self._update_legend()
def draw_viz_markers(self, data, key):
old_items = []
if len(self._viz_marker_items[key]):
for item in self._viz_marker_items[key]:
old_items.append(item)
self._viz_marker_items[key] = []
for viz_marker in data:
if viz_marker['type'] is Marker.TEXT_VIEW_FACING:
# text
viz_marker_text = viz_marker['text']
viz_marker_pose_item = self._scene.addSimpleText(
viz_marker_text, font=QFont())
# Everything must be mirrored
viz_marker_pose_item.translate(-viz_marker['x'],
viz_marker['y'])
elif viz_marker['type'] is Marker.CYLINDER:
# # waypoint
# viz_marker_pose_item = self._scene.addEllipse(viz_marker['x'] - viz_marker['scale'][0] / 2, viz_marker['y'] - viz_marker['scale'][1] / 2, viz_marker['scale'][0], viz_marker['scale'][1], pen=QPen(QColor(255, 0, 0)), brush=QBrush(QColor(255, 0, 0)))
# # Everything must be mirrored
# self._mirror(viz_marker_pose_item)
viz_marker_pose = QMatrix().scale(
1, -1).rotate(viz_marker['yaw'] + 180).map(
self._viz_marker_polygon).translated(
-viz_marker['x'], viz_marker['y'])
viz_marker_pose_item = self._scene.addPolygon(
viz_marker_pose,
pen=QPen(QColor(0, 255, 0)),
brush=QBrush(QColor(0, 255, 0)))
elif viz_marker['type'] is Marker.ARROW:
# marker
# Everything must be mirrored
viz_marker_pose = QMatrix().scale(
1, -1).rotate((viz_marker['yaw'] - 90) + 180).map(
self._viz_marker_polygon).translated(
-viz_marker['x'], viz_marker['y'])
viz_marker_pose_item = self._scene.addPolygon(
viz_marker_pose,
pen=QPen(QColor(255, 0, 0)),
brush=QBrush(QColor(255, 0, 0)))
else:
rospy.logerr("Unknown Marker type : %s" % (viz_marker['type']))
viz_marker_pose_item.setZValue(1)
self._viz_marker_items[key].append(viz_marker_pose_item)
if len(old_items):
for item in old_items:
self._scene.removeItem(item)
def __init__(self, scene, time, color=None):
y2 = len(scene._tracks) * TimelineTrack.height
super(TimelineMarker, self).__init__(time, - TimelineTrack.height, time, y2, None, scene)
self.setZValue(self._z)
if color is None:
color = QColor(self._default_color)
color.setAlphaF(0.5)
self.setPen(QPen(QBrush(color), 0.05))
def _slot_redraw(self):
"""
Gets called either when new msg comes in or when marker is moved by
user.
"""
# update the limits
self._min = 0
self._max = len(self._timeline)-1
# update the marker position
self._xpos_marker = self._timeline.get_position()
self._scene.clear()
qsize = self.size()
width_tl = qsize.width()
w = width_tl / float(max(len(self._timeline), 1))
is_enabled = self.isEnabled()
if self._timeline is not None:
for i, m in enumerate(self._queue):
h = self.viewport().height()
# Figure out each cell's color.
qcolor = QColor('grey')
if is_enabled:
qcolor = self._get_color_for_value(m)
# TODO Use this code for adding gradation to the cell color.
# end_color = QColor(0.5 * QColor('red').value(),
# 0.5 * QColor('green').value(),
# 0.5 * QColor('blue').value())
self._scene.addRect(w * i, 0, w, h, QColor('white'), qcolor)
# Setting marker.
xpos_marker = (self._xpos_marker * w +
(w / 2.0) - (self._timeline_marker_width / 2.0))
pos_marker = QPointF(xpos_marker, 0)
# Need to instantiate marker everytime since it gets deleted
# in every loop by scene.clear()
timeline_marker = self._instantiate_tl_icon()
timeline_marker.setPos(pos_marker)
self._scene.addItem(timeline_marker)
def getNodeItemForNode(self, node, highlight_level):
"""
returns a pyqt NodeItem object, or None in case of error or invisible style
"""
# let pydot imitate pygraphviz api
# attr = {}
# for name in node.get_attributes().iterkeys():
# value = get_unquoted(node, name)
# attr[name] = value
# obj_dic = node.__getattribute__("obj_dict")
# for name in obj_dic:
# if name not in ['attributes', 'parent_graph'] and obj_dic[name] is not None:
# attr[name] = get_unquoted(obj_dic, name)
# node.attr = attr
if 'style' in node.attr:
if node.attr['style'] == 'invis':
return None
color = QColor(node.attr['color']) if 'color' in node.attr else None
name = None
if 'label' in node.attr:
name = node.attr['label']
elif 'name' in node.attr:
name = node.attr['name']
else:
print("Error, no label defined for node with attr: %s" % node.attr)
return None
if name is None:
# happens on Lucid pygraphviz version
print("Error, label is None for node %s, pygraphviz version may be too old." % node)
else:
name = name.decode('string_escape')
# decrease rect by one so that edges do not reach inside
bb_width = len(name) / 5
if 'width' in node.attr:
bb_width = node.attr['width']
bb_height = 1.0
if 'width' in node.attr:
bb_height = node.attr['height']
bounding_box = QRectF(0, 0, POINTS_PER_INCH * float(bb_width) - 1.0, POINTS_PER_INCH * float(bb_height) - 1.0)
pos = (0, 0)
if 'pos' in node.attr:
pos = node.attr['pos'].split(',')
bounding_box.moveCenter(QPointF(float(pos[0]), -float(pos[1])))
node_item = NodeItem(highlight_level=highlight_level,
bounding_box=bounding_box,
label=name,
shape=node.attr.get('shape', 'ellipse'),
color=color,
tooltip=node.attr.get('tooltip', None)
# parent=None,
# label_pos=None
)
# node_item.setToolTip(self._generate_tool_tip(node.attr.get('URL', None)))
return node_item
def add_curve(self, curve_id, curve_name, data_x, data_y):
color = QColor(self._colors[self._color_index % len(self._colors)])
self._color_index += 1
pen = mkPen(color, width=1)
plot = self._plot_widget.plot(name=curve_name, pen=pen)
data_x = numpy.array(data_x)
data_y = numpy.array(data_y)
self._curves[curve_id] = {'x': data_x, 'y': data_y, 'plot': plot}
self._update_legend()
def add_curve(self, curve_id, curve_name, data_x, data_y):
color = QColor(self._colors[self._color_index % len(self._colors)])
self._color_index += 1
pen = mkPen(color, width=2)
# this adds the item to the plot and legend
plot = self._plot_widget.plot(name=curve_name, pen=pen)
data_x = numpy.array(data_x)
data_y = numpy.array(data_y)
self._curves[curve_id] = {'x': data_x, 'y': data_y, 'plot': plot}
def color(self, vel, rpm):
if rpm != 0:
load = vel / rpm
else:
load = 100
if load > 1.5:
return QColor(255, 0, 0)
elif load > 1.3:
#Dunkelorange
return QColor(255, 100, 0)
elif load > 1.1:
#Hellorange
return QColor(240, 165, 0)
elif load >= 0:
return QColor(0, 125, 0)
else:
#Negative Werte -> Rot
return QColor(225, 0, 0)
def choose_brush(index):
"""
Chooses the brush according o the content of a cell.
:param index: the index of the item
:type index: QModelIndex
"""
if index.data() == "ok":
return QColor(127, 255, 0)
elif index.data() == "warning":
return QColor(255, 165, 0)
elif index.data() == "error":
return QColor(255, 0, 0)
else:
print("ERROR: index.data()=%s", index.data())
return QColor(255, 255, 255) # XXX
return None
def portSelected(self, index):
for e in self.prev_selected_connections:
e.setPen(QPen(QBrush(QColor(0, 0, 0)), 0))
self.prev_selected_connections = []
if not self.component_selected:
return
for conn in self.parent.all_connections:
if (conn[0] == self.component_selected and conn[1] == self.selected_component_port_names[index]) or \
(conn[2] == self.component_selected and conn[3] == self.selected_component_port_names[index]):
for graph_name in self.edges:
for e in self.edges[graph_name]:
data = e.data(0)
if (data[0] == conn[0] and data[1] == conn[2]) or \
(data[0] == conn[2] and data[1] == conn[0]):
e.setPen(QPen(QBrush(QColor(255, 0, 0)), 5))
self.prev_selected_connections.append(e)
def __init__(self, context):
super(Eyedrop, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('Eyedrop')
rp = rospkg.RosPack()
# 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")
self.args, unknowns = parser.parse_known_args(context.argv())
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(rp.get_path('rqt_eyedropper'), 'resource',
'Eyedrop.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('EyedropUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self._widget.button_refresh_topics.clicked.connect(
self.button_refresh_topics_pressed)
self._widget.button_take_sample.clicked.connect(
self.button_take_sample_pressed)
self._widget.combo_box_topic_image.currentIndexChanged.connect(
self.do_subscribe_image)
self._widget.combo_box_topic_point.currentIndexChanged.connect(
self.do_subscribe_point)
self.colour_pane_scene = QGraphicsScene()
self.colour_pane_scene.setBackgroundBrush(QBrush(QColor(0, 0, 0)))
self._widget.graphics_view_colour_pane.setScene(self.colour_pane_scene)
self._widget.graphics_view_colour_pane.show()
self.bridge = CvBridge()
self.do_refresh_topic_lists()
def getNodeItemForSubgraph(self, subgraph, highlight_level):
# let pydot imitate pygraphviz api
attr = {}
for name in subgraph.get_attributes().iterkeys():
value = get_unquoted(subgraph, name)
attr[name] = value
obj_dic = subgraph.__getattribute__("obj_dict")
for name in obj_dic:
if name not in ['nodes', 'attributes', 'parent_graph'
] and obj_dic[name] is not None:
attr[name] = get_unquoted(obj_dic, name)
elif name == 'nodes':
for key in obj_dic['nodes']['graph'][0]['attributes']:
attr[key] = get_unquoted(
obj_dic['nodes']['graph'][0]['attributes'], key)
subgraph.attr = attr
bb = subgraph.attr.get('bb', None)
if bb is None:
# no bounding box
return None
bb = bb.strip('"').split(',')
if len(bb) < 4:
# bounding box is empty
return None
bounding_box = QRectF(0, 0,
float(bb[2]) - float(bb[0]),
float(bb[3]) - float(bb[1]))
if 'lp' in subgraph.attr:
label_pos = subgraph.attr['lp'].strip('"').split(',')
else:
label_pos = (float(bb[0]) + (float(bb[2]) - float(bb[0])) / 2,
float(bb[1]) + (float(bb[3]) - float(bb[1])) -
LABEL_HEIGHT / 2)
bounding_box.moveCenter(
QPointF(
float(bb[0]) + (float(bb[2]) - float(bb[0])) / 2,
-float(bb[1]) - (float(bb[3]) - float(bb[1])) / 2))
name = subgraph.attr.get('label', '')
color = QColor(
subgraph.attr['color']) if 'color' in subgraph.attr else None
subgraph_nodeitem = NodeItem(highlight_level,
bounding_box,
label=name,
shape='box',
color=color,
label_pos=QPointF(float(label_pos[0]),
-float(label_pos[1])))
bounding_box = QRectF(bounding_box)
# With clusters we have the problem that mouse hovers cannot
# decide whether to be over the cluster or a subnode. Using
# just the "title area" solves this. TODO: Maybe using a
# border region would be even better (multiple RectF)
bounding_box.setHeight(LABEL_HEIGHT)
subgraph_nodeitem.set_hovershape(bounding_box)
return subgraph_nodeitem
def __init__(self, filename, parent=None):
self.parent = parent
QTextEdit.__init__(self, parent)
self.setObjectName('Editor - %s' % filename)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_custom_context_menu)
# self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.setAcceptRichText(False)
font = QFont()
font.setFamily("Fixed".decode("utf-8"))
font.setPointSize(12)
self.setFont(font)
self.setLineWrapMode(QTextEdit.NoWrap)
self.setTabStopWidth(25)
self.setAcceptRichText(False)
self.setCursorWidth(2)
self.setFontFamily("courier new")
self.setProperty("backgroundVisible", True)
bg_style = "QTextEdit { background-color: #fffffc;}"
self.setStyleSheet("%s" % (bg_style))
self.setTextColor(QColor(0, 0, 0))
self.regexp_list = [QRegExp("\\binclude\\b"), QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"), QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b"),
QRegExp("\\bargs=.*\$\(find\\b"),
QRegExp("\\bdefault=.*\$\(find\\b")]
self.filename = filename
self.file_mtime = 0
# f = QFile(filename)
# if f.open(QIODevice.ReadOnly | QIODevice.Text):
# self.file_info = QFileInfo(filename)
# self.setText(unicode(f.readAll(), "utf-8"))
self.path = '.'
# enables drop events
self.setAcceptDrops(True)
# variables for threaded search
self._search_thread = None
self._stop = False
self._internal_args = {}
ext = os.path.splitext(filename)
if self.filename:
self.setText("")
_, self.file_mtime, file_content = nm.nmd().file.get_file_content(filename)
if ext[1] in ['.launch', '.xml']:
self._internal_args = get_internal_args(file_content)
self.setText(file_content)
self._is_launchfile = False
if ext[1] in ['.launch', '.xml', '.xacro', '.srdf', '.urdf']:
if ext[1] in ['.launch']:
self._is_launchfile = True
self.hl = XmlHighlighter(self.document(), is_launch=False)
self.cursorPositionChanged.connect(self._document_position_changed)
else:
self.hl = YamlHighlighter(self.document())
def __init__(self, parent=None):
QSyntaxHighlighter.__init__(self, parent)
self.rules = []
self.commentStart = QRegExp("#")
self.commentEnd = QRegExp("\n|\r")
self.default_format = QTextCharFormat()
self.default_format.setForeground(QColor(24, 24, 24))
self.commentFormat = QTextCharFormat()
self.commentFormat.setFontItalic(True)
self.commentFormat.setForeground(Qt.darkGray)
tagList = ["\\btrue\\b", "\\bfalse\\b"]
# create patterns for tags
for tag in tagList:
self.rules.append((self._create_regexp(tag), self._create_format(Qt.blue)))
# create pattern for digits
self.rules.append((self._create_regexp("\\d+"), self._create_format(QColor(127, 64, 127))))
# create pattern for params
self.rules.append((self._create_regexp("\s*[_.\w]*\s*:"), self._create_format(Qt.darkBlue)))
# create pattern for params
self.rules.append((self._create_regexp(":\s*:[_\.\w]*$|:\s*\@[_\.\w]*$"), self._create_format(Qt.darkBlue)))
# create pattern for list signes
self.rules.append((self._create_regexp("^\s*-"), self._create_format(Qt.darkRed, 'bold')))
# create pattern for ???
self.rules.append((self._create_regexp("^---$"), self._create_format(Qt.darkRed)))
# create pattern for braces
self.rules.append((self._create_regexp("[\[\]\{\}\,]"), self._create_format(Qt.darkGreen)))
# create patterns for strings
self.rules.append((self._create_regexp("\".*\"|\'.*\'"), self._create_format(Qt.blue)))
# create patterns for substitutions
self.rules.append((self._create_regexp("\\$\\(.*\\)"), self._create_format(QColor(127, 64, 127))))
# create patterns for DOCTYPE
self.rules.append((self._create_regexp("<!DOCTYPE.*>"), self._create_format(Qt.lightGray)))
self.rules.append((self._create_regexp("<\\?xml.*\\?>"), self._create_format(Qt.lightGray)))
def _update_path(self, name):
old_item = None
if name in self._paths.keys():
old_item = self._paths[name].item
self._paths[name].item = self._scene.addPath(
self._paths[name].path, pen=QPen(QColor(*self._paths[name].color)))
if old_item:
self._scene.removeItem(old_item)
def btn_color_clicked(self):
frame = self.editor.active_frame
color = QtWidgets.QColorDialog.getColor(
QColor(frame.color[0] * 255, frame.color[1] * 255,
frame.color[2] * 255, frame.color[3] * 255),
None,
"Select Color",
options=QtWidgets.QColorDialog.ShowAlphaChannel)
self.editor.command(
Command_SetStyleColor(self.editor, frame, color.getRgbF()))
def paint(self, painter, option, index):
is_dark = True
item = self.parent().item(index.row())
if item.faulty:
pen = QPen(QColor(255, 117, 117), 3)
painter.setPen(pen)
painter.drawRect(option.rect)
elif item == self.parent().currentItem():
pen = QPen(Qt.white, 3)
painter.setPen(pen)
painter.drawRect(option.rect)
if not item.has_script:
painter.fillRect(option.rect, QColor(153, 153, 153))
else:
painter.fillRect(option.rect, Qt.white)
is_dark = False
doc = QTextDocument()
highlight = syntax.PythonHighlighter(doc, is_dark = is_dark)
font = QFont("Courier")
font.setFamily("Courier");
font.setStyleHint(QFont.Monospace);
font.setFixedPitch(True);
font.setPointSize(self.parent().font().pointSize())
doc.setDefaultFont(font)
text = index.data(Qt.EditRole)
text = text.replace("\t", ''.join([' '] * 4))
doc.setPlainText(text)
doc.setDefaultStyleSheet("background-color: red;")
painter.translate(option.rect.topLeft())
doc.drawContents(painter)
painter.resetTransform()
def add_curve(self,
curve_id,
curve_name,
curve_color=QColor(Qt.blue),
markers_on=False):
pen = mkPen(curve_color, width=1)
# this adds the item to the plot and legend
plot = self._plot_widget.plot(stepMode=True,
fillLevel=0,
brush=(0, 0, 255, 150))
self._curves[curve_id] = plot
def add_curve(self,
curve_id,
curve_name,
curve_color=QColor(Qt.blue),
markers_on=False):
pen = mkPen(curve_color, width=1)
symbol = "o"
symbolPen = mkPen(QColor(Qt.black))
symbolBrush = mkBrush(curve_color)
# this adds the item to the plot and legend
if markers_on:
plot = self._plot_widget.plot(name=curve_name,
pen=pen,
symbol=symbol,
symbolPen=symbolPen,
symbolBrush=symbolBrush,
symbolSize=4)
else:
plot = self._plot_widget.plot(name=curve_name, pen=pen)
self._curves[curve_id] = plot
def add_curve(self, curve_id, curve_name, x, y):
color = QColor(self._colors[self._color_index % len(self._colors)])
self._color_index += 1
line = self._canvas.axes.plot([], [],
label=curve_name,
linewidth=1,
picker=5,
color=color.name())[0]
self._curves[curve_id] = ([], [], line, [None, None])
self.update_values(curve_id, x, y)
self._update_legend()
def add_curve(self, curve_id, curve_name, curve_color=QColor(Qt.blue), markers_on=False):
curve_id = str(curve_id)
if curve_id in self._curves:
return
curve_object = Qwt.QwtPlotCurve(curve_name)
curve_object.attach(self)
curve_object.setPen(curve_color)
if markers_on:
curve_object.setSymbol(
Qwt.QwtSymbol(Qwt.QwtSymbol.Ellipse, QBrush(curve_color), QPen(Qt.black), QSize(4, 4)))
self._curves[curve_id] = curve_object
def _get_zones(self, msg):
zones = {}
for marker in msg.markers:
polygon = []
color = QColor(255*marker.color.r, 255*marker.color.g, 255*marker.color.b, 255*marker.color.a)
for p in marker.points:
polygon.append(QPointF(p.x * SandtrayItem.scale, -p.y * SandtrayItem.scale))
zones.setdefault(color, []).append(polygon)
return zones
def set_color(self, rpms, vel, column):
"""Takes three rpm values in a list and inserts the appropriate colour into the rows of the specified column"""
if vel != 0:
vel *= 100
for i in range(0, 3):
self._ui.MotorTable.item(i, column).setBackground(
self.color(vel, rpms[i]))
else:
for i in range(0, 3):
self._ui.MotorTable.item(i, column).setBackground(
QColor(125, 125, 125))
def _update_status(self, status):
if status == -1:
self._widget.safety_mode.setText('UNKNOWN SAFETY MODE')
self._widget.safety_mode.setToolTip(
'The WAM is in an unknown state. Proceed with caution.')
color = QColor(200, 200, 200)
self._widget.button_set_home.setEnabled(False)
self._widget.button_idle_wam.setEnabled(False)
self._widget.button_run_wam.setEnabled(False)
elif status == 0:
self._widget.safety_mode.setText('E-STOP')
self._widget.safety_mode.setToolTip(
'The WAM is stopped and unpowered. Determine the source of the fault and reset the arm to continue using it.'
)
self._widget.button_set_home.setEnabled(False)
self._widget.button_idle_wam.setEnabled(False)
self._widget.button_run_wam.setEnabled(False)
color = self.barrett_red
else:
if not self.homed:
self._widget.safety_mode.setText('UNCALIBRATED')
self._widget.safety_mode.setToolTip(
'The WAM is not calibrated. Please place it in the calibration posture and click the "Calibrate" button.'
)
self._widget.button_set_home.setEnabled(True)
self._widget.button_idle_wam.setEnabled(False)
self._widget.button_run_wam.setEnabled(False)
color = self.barrett_orange
else:
if status == 1:
self._widget.safety_mode.setText('IDLE')
self._widget.safety_mode.setToolTip(
'The WAM is running but all joints are passive. It is safe to home the arm.'
)
self._widget.button_set_home.setEnabled(True)
self._widget.button_idle_wam.setEnabled(True)
self._widget.button_run_wam.setEnabled(True)
color = self.barrett_blue
elif status == 2:
self._widget.safety_mode.setText('ACTIVE')
self._widget.safety_mode.setToolTip(
'The WAM is running and all joints are active. Proceed with caution.'
)
self._widget.button_set_home.setEnabled(False)
self._widget.button_idle_wam.setEnabled(False)
self._widget.button_run_wam.setEnabled(False)
color = self.barrett_green
darker = color.darker()
lighter = color.lighter()
self._widget.safety_mode.setStyleSheet(
"QLabel { background-color : rgb(%d,%d,%d); color : rgb(%d,%d,%d); }"
% (color.red(), color.green(), color.blue(), lighter.red(),
lighter.green(), lighter.blue()))
class HoveredEdgeItem(EdgeItem):
HIGHLIGHT_LEVEL = 1
HOVERED_COLOR = QColor(250, 0, 0)
def __init__(self, spline, label, label_center, from_node, to_node,
parent=None, **kwargs):
super(HoveredEdgeItem, self).__init__(spline, label, label_center, from_node, to_node, parent, **kwargs)
self._highlight_level = kwargs.get('highlight_level', self.HIGHLIGHT_LEVEL)
self._hovered_color = kwargs.get('hovered_color', self.HOVERED_COLOR)
if self._label is not None:
self._label.hoverEnterEvent = self.hoverEnterEvent
self._label.hoverLeaveEvent = self.hoverLeaveEvent
self._label.setAcceptHoverEvents(True)
if self._arrow is not None:
self._arrow.hoverEnterEvent = self.hoverEnterEvent
self._arrow.hoverLeaveEvent = self.hoverLeaveEvent
self._arrow.setAcceptHoverEvents(True)
def hoverEnterEvent(self, event):
# hovered edge item in red
self.set_color(self._hovered_color)
self._highlight_connections()
def hoverLeaveEvent(self, event):
self.set_color()
self._highlight_connections(False)
def _highlight_connections(self, highlighted=True):
if highlighted:
if self._highlight_level > 1:
if self.from_node != self.to_node:
# from-node in blue
self.from_node.set_color(self.COLOR_BLUE)
# to-node in green
self.to_node.set_color(self.COLOR_GREEN)
else:
# from-node/in-node in teal
self.from_node.set_color(self.COLOR_TEAL)
self.to_node.set_color(self.COLOR_TEAL)
if self._highlight_level > 2:
# sibling edges in orange
for sibling_edge in self._sibling_edges:
sibling_edge.set_color(self.COLOR_ORANGE)
else:
if self._highlight_level > 1:
self.from_node.set_color()
self.to_node.set_color()
if self._highlight_level > 2:
for sibling_edge in self._sibling_edges:
sibling_edge.set_color()
def __init__(self, parent=None, info=False):
QFrame.__init__(self, parent=parent)
self.setObjectName('MessageFrame')
self.questionid = self.TYPE_INVALID
self.text = ""
self.data = MessageData(None)
self.IMAGES = {1: QPixmap(),
2: nm.settings().pixmap('question.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
3: nm.settings().pixmap('crystal_clear_launch_file.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
4: nm.settings().pixmap('default_cfg.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
5: nm.settings().pixmap('crystal_clear_nodelet_q.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
6: nm.settings().pixmap('crystal_clear_launch_file_transfer.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
7: nm.settings().pixmap('crystal_clear_binary.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
8: nm.settings().pixmap('crystal_clear_no_io.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
9: nm.settings().pixmap('crystal_clear_run_zeroconf.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
10: nm.settings().pixmap('sekkyumu_restart.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
}
self._new_request = False
self._in_resp_process = False
self.ui = QFrame()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ui', 'MessageFrame.ui')
loadUi(ui_file, self.ui)
color = QColor(255, 207, 121)
self.ui.questionOkButton.setIcon(nm.settings().icon('crystal_clear_button_apply.png'))
self.ui.questionCancelButton.setIcon(nm.settings().icon('crystal_clear_button_close.png'))
self.ui.listLabel.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.ui.questionLabel.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.ui.setVisible(False)
self.ui.listLabel.setVisible(False)
self.ui.questionOkButton.clicked.connect(self._on_question_ok)
self.ui.questionCancelButton.clicked.connect(self._on_question_cancel)
self.ui.checkBox_dnaa.stateChanged.connect(self._on_checkbox_state_changed)
self._ask = 'ask'
if info:
color = QColor(232, 104, 80)
self.ui.questionCancelButton.setVisible(False)
self._ask = 'show'
bg_style = "QFrame#questionFame { background-color: %s;}" % color.name()
self.ui.setStyleSheet("%s" % (bg_style))
self._queue = MessageQueue()
self._do_not_ask = {}
def _show_capture_teleop_message(self, rtn):
if rtn:
QMessageBox.warning(self._widget, 'SUCCESS', "CAPTURE!!!!",
QMessageBox.Ok | QMessageBox.Ok)
for k in self.robot_item_list.keys():
if self.robot_item_list[k] == self.current_robot:
k.setBackground(0, QBrush(Qt.SolidPattern))
k.setBackgroundColor(0, QColor(0, 255, 0, 255))
robot_name = k.text(0)
k.setText(0, str(robot_name) + " (captured)")
else:
k.setBackground(0, QBrush(Qt.NoBrush))
k.setBackgroundColor(0, QColor(0, 0, 0, 0))
robot_name = k.text(0)
self._widget.capture_teleop_btn.setEnabled(False)
self._widget.release_teleop_btn.setEnabled(True)
self.current_captured_robot = self.current_robot
else:
QMessageBox.warning(self._widget, 'FAIL', "FAIURE CAPTURE!!!!",
QMessageBox.Ok | QMessageBox.Ok)
self._widget.setDisabled(False)
def add_curve(self, curve_id, curve_name, x, y):
color = QColor(self._colors[self._color_index % len(self._colors)])
self._color_index += 1
# line = self._canvas.axes.plot(
# [], [], label=curve_name, linewidth=1, picker=5,
# color=color.name())[0]
line = None
self._curves[curve_id] = [[], [], line, [None, None],
(color.red() / 255.0, color.green() / 255.0,
color.blue() / 255.0, 0.6)]
self.update_values(curve_id, x, y)
self._update_legend()
