class TakeDragGame(QWidget):
def __init__(self, parent=None):
super(TakeDragGame, self).__init__(parent)
# This is always the same
self.dot2 = QGraphicsTextItem(':')
self.dot1 = QGraphicsTextItem(':')
self.animations = []
self.digits = []
self.main_layout = QHBoxLayout()
self.setLayout(self.main_layout)
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 600, 400)
self.view = QGraphicsView()
self.view.setScene(self.scene)
# TODO: Check if its better with opengl or not
# self.view.setViewport(QtOpenGL.QGLWidget())
self.main_layout.addWidget(self.view)
# self.setWindowState(Qt.WindowMaximized)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.image_bank = None
self.create_and_add_images()
# self.scene.setBackgroundBrush(QBrush(Qt.red, Qt.SolidPattern))
# self.populate()
# self.animator = QTimer()
# self.animator.timeout.connect(self.animate)
# self.animate()
def create_and_add_images(self):
self.load_images_json_file()
self.add_background_to_image()
self.add_background_from_image()
if self.image_bank is not None:
for image_id in self.image_bank.keys():
if "clothes" in self.image_bank[image_id]["categories"]:
image_path = self.image_bank[image_id]["path"]
new_image = DraggableItem(image_path, self.background_from_image)
new_image.moved_signal.moved.connect(self.item_moved)
self.image_bank[image_id]["widget"] = new_image
newpos_x = self.background_from_image.boundingRect().width() / 2 - new_image.boundingRect().width() / 2
newpos_y = self.background_from_image.boundingRect().height() / 2 - new_image.boundingRect().height() / 2
new_image.setPos(newpos_x, newpos_y)
# self.scene.addItem(new_image)
new_image.setZValue(30)
def item_moved(self, pos):
widget = self.sender().get_parent()
print widget.zValue()
print self.background_from_image.zValue()
print self.background_to_image.zValue()
item_br = widget.sceneBoundingRect()
if self.background_from_image.sceneBoundingRect().contains(item_br):
widget.setParentItem(self.background_from_image)
newpos_x = self.background_from_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2
newpos_y = self.background_from_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2
# self.background_to_image.stackBefore(self.background_from_image)
widget.setPos(newpos_x, newpos_y)
elif self.background_to_image.sceneBoundingRect().contains(item_br):
widget.setParentItem(self.background_to_image)
newpos_x = self.background_to_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2
newpos_y = self.background_to_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2
# self.background_from_image.stackBefore(self.background_to_image)
widget.setPos(newpos_x, newpos_y)
def load_images_json_file(self):
with open(os.path.join(CURRENT_PATH, './resources/images.json')) as f:
self.image_bank = json.load(f)
def add_background_from_image(self, ):
assert self.image_bank is not None, "Images need to be loaded before calling this method (try load_images_json_file)"
if "Background from" in self.image_bank:
background_from_pixmap = QPixmap(self.image_bank["Background from"]["path"])
self.background_from_image = QGraphicsPixmapItem(background_from_pixmap)
self.scene.addItem(self.background_from_image)
self.background_from_image.setZValue(2)
def add_background_to_image(self, ):
assert self.image_bank is not None, "Images need to be loaded before calling this method (try load_images_json_file)"
if "Background to" in self.image_bank:
background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"])
self.background_to_image = QGraphicsPixmapItem(background_to_pixmap)
self.scene.addItem(self.background_to_image)
self.background_to_image.setZValue(2)
def resizeEvent(self, event):
view_size = self.view.size()
new_background_height = (1.5 / 4.) * view_size.height()
background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"])
background_to_pixmap = background_to_pixmap.scaled(new_background_height, new_background_height,
Qt.KeepAspectRatio)
if not self.background_to_image:
self.background_to_image = QGraphicsPixmapItem(background_to_pixmap)
else:
self.background_to_image.setPixmap(background_to_pixmap)
sugested_x_position = int(2 * (view_size.width() / 3.))
if sugested_x_position < 0:
sugested_x_position = 0
sugested_y_position = int(view_size.height() / 2. - background_to_pixmap.size().height() / 2)
if sugested_y_position < 0:
sugested_y_position = 0
self.background_to_image.setPos(sugested_x_position, sugested_y_position)
#####################
new_background_height = (2.2 / 4.) * view_size.height()
background_from_pixmap = QPixmap(self.image_bank["Background from"]["path"])
background_from_pixmap = background_from_pixmap.scaled(new_background_height, new_background_height,
Qt.KeepAspectRatio)
if not self.background_to_image:
self.background_from_image = QGraphicsPixmapItem(background_from_pixmap)
else:
self.background_from_image.setPixmap(background_from_pixmap)
sugested_x_position = int(view_size.width() / 5. - background_from_pixmap.size().height() / 2)
if sugested_x_position < 0:
sugested_x_position = 0
sugested_y_position = int(view_size.height() / 2. - background_from_pixmap.size().height() / 2)
if sugested_y_position < 0:
sugested_y_position = 0
self.background_from_image.setPos(sugested_x_position, sugested_y_position)
####
new_widget_height = (1 / 4.) * view_size.height()
if self.image_bank is not None:
for image_id in self.image_bank.keys():
if "clothes" in self.image_bank[image_id]["categories"]:
widget = self.image_bank[image_id]["widget"]
pixmap = widget.pixmap
pixmap = pixmap.scaled(new_widget_height, new_widget_height,
Qt.KeepAspectRatio)
widget.setPixmap(pixmap)
print widget.moved_flag
if not widget.moved_flag:
newpos_x = self.background_from_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2
newpos_y = self.background_from_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2
widget.setPos(newpos_x, newpos_y)
super(TakeDragGame, self).resizeEvent(event)
class EditLinksNode(QGraphicsWidget):
"""
A Node representation with channel anchors.
`direction` specifies the layout (default `Qt.LeftToRight` will
have icon on the left and channels on the right).
"""
def __init__(self, parent=None, direction=Qt.LeftToRight,
node=None, icon=None, iconSize=None, **args):
QGraphicsWidget.__init__(self, parent, **args)
self.setAcceptedMouseButtons(Qt.NoButton)
self.__direction = direction
self.setLayout(QGraphicsLinearLayout(Qt.Horizontal))
# Set the maximum size, otherwise the layout can't grow beyond its
# sizeHint (and we need it to grow so the widget can grow and keep the
# contents centered vertically.
self.layout().setMaximumSize(QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX))
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__iconSize = iconSize or QSize(64, 64)
self.__icon = icon
self.__iconItem = QGraphicsPixmapItem(self)
self.__iconLayoutItem = GraphicsItemLayoutItem(item=self.__iconItem)
self.__channelLayout = QGraphicsGridLayout()
self.__channelAnchors = []
if self.__direction == Qt.LeftToRight:
self.layout().addItem(self.__iconLayoutItem)
self.layout().addItem(self.__channelLayout)
channel_alignemnt = Qt.AlignRight
else:
self.layout().addItem(self.__channelLayout)
self.layout().addItem(self.__iconLayoutItem)
channel_alignemnt = Qt.AlignLeft
self.layout().setAlignment(self.__iconLayoutItem, Qt.AlignCenter)
self.layout().setAlignment(self.__channelLayout,
Qt.AlignVCenter | channel_alignemnt)
if node is not None:
self.setSchemeNode(node)
def setIconSize(self, size):
"""
Set the icon size for the node.
"""
if size != self.__iconSize:
self.__iconSize = QSize(size)
if self.__icon:
self.__iconItem.setPixmap(self.__icon.pixmap(size))
self.__iconLayoutItem.updateGeometry()
def iconSize(self):
"""
Return the icon size.
"""
return QSize(self.__iconSize)
def setIcon(self, icon):
"""
Set the icon to display.
"""
if icon != self.__icon:
self.__icon = QIcon(icon)
self.__iconItem.setPixmap(icon.pixmap(self.iconSize()))
self.__iconLayoutItem.updateGeometry()
def icon(self):
"""
Return the icon.
"""
return QIcon(self.__icon)
def setSchemeNode(self, node):
"""
Set an instance of `SchemeNode`. The widget will be initialized
with its icon and channels.
"""
self.node = node
if self.__direction == Qt.LeftToRight:
channels = node.output_channels()
else:
channels = node.input_channels()
self.channels = channels
loader = icon_loader.from_description(node.description)
icon = loader.get(node.description.icon)
self.setIcon(icon)
label_template = ('<div align="{align}">'
'<b class="channelname">{name}</b><br/>'
'<span class="typename">{typename}</span>'
'</div>')
if self.__direction == Qt.LeftToRight:
align = "right"
label_alignment = Qt.AlignVCenter | Qt.AlignRight
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 0
anchor_row = 1
else:
align = "left"
label_alignment = Qt.AlignVCenter | Qt.AlignLeft
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 1
anchor_row = 0
self.__channelAnchors = []
grid = self.__channelLayout
for i, channel in enumerate(channels):
text = label_template.format(align=align,
name=escape(channel.name),
typename=escape(channel.type))
text_item = GraphicsTextWidget(self)
text_item.setHtml(text)
text_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
grid.addItem(text_item, i, label_row,
alignment=label_alignment)
anchor = ChannelAnchor(self, channel=channel,
rect=QRectF(0, 0, 20, 20))
anchor.setBrush(self.palette().brush(QPalette.Mid))
layout_item = GraphicsItemLayoutItem(grid, item=anchor)
grid.addItem(layout_item, i, anchor_row,
alignment=anchor_alignment)
if hasattr(channel, "description"):
text_item.setToolTip((channel.description))
self.__channelAnchors.append(anchor)
def anchor(self, channel):
"""
Return the anchor item for the `channel` name.
"""
for anchor in self.__channelAnchors:
if anchor.channel() == channel:
return anchor
raise ValueError(channel.name)
def paint(self, painter, option, widget=None):
painter.save()
palette = self.palette()
border = palette.brush(QPalette.Mid)
pen = QPen(border, 1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.setBrush(palette.brush(QPalette.Window))
brect = self.boundingRect()
painter.drawRoundedRect(brect, 4, 4)
painter.restore()
class ProbabilitiesItem(orangeqt.PlotItem):
"""
Displays class probabilities in the background
:param classifier: The classifier for which the probabilities are calculated
:type classifier: orange.P2NN
:param granularity: The size of individual cells
:type granularity: int
:param scale: The data scale factor
:type scale: float
:param spacing: The space between cells
:param spacing: int
:param rect: The rectangle into which to draw the probabilities. If unspecified, the entire plot is used.
:type rect: QRectF
"""
def __init__(self, classifier, granularity, scale, spacing, rect=None):
orangeqt.PlotItem.__init__(self)
self.classifier = classifier
self.rect = rect
self.granularity = granularity
self.scale = scale
self.spacing = spacing
self.pixmap_item = QGraphicsPixmapItem(self)
self.set_in_background(True)
self.setZValue(ProbabilitiesZValue)
def update_properties(self):
## Mostly copied from OWScatterPlotGraph
if not self.plot():
return
if not self.rect:
x, y = self.axes()
self.rect = self.plot().data_rect_for_axes(x, y)
s = self.graph_transform().mapRect(self.rect).size().toSize()
if not s.isValid():
return
rx = s.width()
ry = s.height()
rx -= rx % self.granularity
ry -= ry % self.granularity
p = self.graph_transform().map(QPointF(
0, 0)) - self.graph_transform().map(self.rect.topLeft())
p = p.toPoint()
ox = p.x()
oy = -p.y()
if self.classifier.classVar.is_continuous:
imagebmp = orangeom.potentialsBitmap(self.classifier, rx, ry, ox,
oy, self.granularity,
self.scale)
palette = [
qRgb(255. * i / 255., 255. * i / 255., 255 - (255. * i / 255.))
for i in range(255)
] + [qRgb(255, 255, 255)]
else:
imagebmp, nShades = orangeom.potentialsBitmap(
self.classifier, rx, ry, ox, oy, self.granularity, self.scale,
self.spacing)
palette = []
sortedClasses = get_variable_values_sorted(
self.classifier.domain.classVar)
for cls in self.classifier.classVar.values:
color = self.plot().discPalette.getRGB(
sortedClasses.index(cls))
towhite = [255 - c for c in color]
for s in range(nShades):
si = 1 - float(s) / nShades
palette.append(
qRgb(*tuple(
[color[i] + towhite[i] * si for i in (0, 1, 2)])))
palette.extend(
[qRgb(255, 255, 255) for i in range(256 - len(palette))])
self.potentialsImage = QImage(imagebmp, rx, ry, QImage.Format_Indexed8)
self.potentialsImage.setColorTable(
ColorPaletteDlg.signedPalette(palette
) if qVersion() < "4.5" else palette)
self.potentialsImage.setNumColors(256)
self.pixmap_item.setPixmap(QPixmap.fromImage(self.potentialsImage))
self.pixmap_item.setPos(self.graph_transform().map(
self.rect.bottomLeft()))
def data_rect(self):
return self.rect if self.rect else QRectF()
class ProbabilitiesItem(orangeqt.PlotItem):
"""
Displays class probabilities in the background
:param classifier: The classifier for which the probabilities are calculated
:type classifier: orange.P2NN
:param granularity: The size of individual cells
:type granularity: int
:param scale: The data scale factor
:type scale: float
:param spacing: The space between cells
:param spacing: int
:param rect: The rectangle into which to draw the probabilities. If unspecified, the entire plot is used.
:type rect: QRectF
"""
def __init__(self, classifier, granularity, scale, spacing, rect=None):
orangeqt.PlotItem.__init__(self)
self.classifier = classifier
self.rect = rect
self.granularity = granularity
self.scale = scale
self.spacing = spacing
self.pixmap_item = QGraphicsPixmapItem(self)
self.set_in_background(True)
self.setZValue(ProbabilitiesZValue)
def update_properties(self):
## Mostly copied from OWScatterPlotGraph
if not self.plot():
return
if not self.rect:
x, y = self.axes()
self.rect = self.plot().data_rect_for_axes(x, y)
s = self.graph_transform().mapRect(self.rect).size().toSize()
if not s.isValid():
return
rx = s.width()
ry = s.height()
rx -= rx % self.granularity
ry -= ry % self.granularity
p = self.graph_transform().map(QPointF(0, 0)) - self.graph_transform().map(self.rect.topLeft())
p = p.toPoint()
ox = p.x()
oy = -p.y()
if isinstance(self.classifier.classVar, ContinuousVariable):
imagebmp = orangeom.potentialsBitmap(self.classifier, rx, ry, ox, oy, self.granularity, self.scale)
palette = [qRgb(255.0 * i / 255.0, 255.0 * i / 255.0, 255 - (255.0 * i / 255.0)) for i in range(255)] + [
qRgb(255, 255, 255)
]
else:
imagebmp, nShades = orangeom.potentialsBitmap(
self.classifier, rx, ry, ox, oy, self.granularity, self.scale, self.spacing
)
palette = []
sortedClasses = get_variable_values_sorted(self.classifier.domain.classVar)
for cls in self.classifier.classVar.values:
color = self.plot().discPalette.getRGB(sortedClasses.index(cls))
towhite = [255 - c for c in color]
for s in range(nShades):
si = 1 - float(s) / nShades
palette.append(qRgb(*tuple([color[i] + towhite[i] * si for i in (0, 1, 2)])))
palette.extend([qRgb(255, 255, 255) for i in range(256 - len(palette))])
self.potentialsImage = QImage(imagebmp, rx, ry, QImage.Format_Indexed8)
self.potentialsImage.setColorTable(ColorPaletteDlg.signedPalette(palette) if qVersion() < "4.5" else palette)
self.potentialsImage.setNumColors(256)
self.pixmap_item.setPixmap(QPixmap.fromImage(self.potentialsImage))
self.pixmap_item.setPos(self.graph_transform().map(self.rect.bottomLeft()))
def data_rect(self):
return self.rect if self.rect else QRectF()
class Scene(QGraphicsScene):
def __init__(self, lblXY, spinId, spinX, spinY, btnAddEdge, btnDeleteEdge, spinCommRange, spinEnvX, spinEnvY, comboChannelType):
super(self.__class__, self).__init__()
self.net = pymote.Network()
self.net_dict = {} #for keeping pairs of net_node and scene_node
self.comm_range = 200
self.curr_id = 1
self.node_size = 15
self.node_color = QtCore.Qt.blue
self.pressed_color = QtCore.Qt.red
self.lblXY = lblXY #shows x,y position on scene
self.spinId = spinId
self.spinId.setEnabled(False)
self.spinX = spinX
self.spinY = spinY
self.btnAddEdge = btnAddEdge
self.btnDeleteEdge = btnDeleteEdge
self.spinEnvX = spinEnvX
self.spinEnvY = spinEnvY
self.comboChannelType = comboChannelType
self.hide_btn_edge() #on start: auto edge mode selected -> buttons add and delete edge not needed
self.hide_pressed_item_data() #on start: no item is pressed -> hide item data
self.spinCommRange = spinCommRange
self.spinCommRange.setValue(self.comm_range)
self.f_show_radius = False
self.f_auto_edge = True
self.f_move = False
self.f_moved = False
self.f_show_env = True
self.f_opening_net = False
self.option = 0
self.edge_option = 0
self.last_pressed_node = 0
self.radius = 0
self.environment = pymote.Environment()
self.scene_env = 0
self.envX = 600
self.envY = 600
self.channel_type = self.comboChannelType.currentText()
self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY))
def ini_scene(self):
self.clear()
new_net = pymote.Network()
self.net = new_net
self.net_dict.clear()
self.curr_id = 1
self.option = 0
self.edge_option = 0
self.last_pressed_node = 0
self.radius = 0
self.environment = pymote.Environment()
self.scene_env = 0
def get_net(self):
return self.net
def hide_pressed_item_data(self):
#self.spinId.setEnable(False)
self.spinId.setValue(0)
self.spinX.setEnabled(False)
self.spinX.setValue(0)
self.spinY.setEnabled(False)
self.spinY.setValue(0)
def show_pressed_item_data(self):
#self.spinId.setEnable(True)
self.spinId.setValue(self.last_pressed_node.node_id)
self.spinX.setEnabled(True)
self.spinX.setValue(self.last_pressed_node.get_X())
self.spinY.setEnabled(True)
self.spinY.setValue(-self.last_pressed_node.get_Y())
def hide_btn_edge(self):
self.btnAddEdge.setEnabled(False)
self.btnDeleteEdge.setEnabled(False)
def show_btn_edge(self):
self.btnAddEdge.setEnabled(True)
self.btnDeleteEdge.setEnabled(True)
def auto_add_edge(self, toggle):
if toggle.isChecked() == True:
self.f_auto_edge = True
self.hide_btn_edge()
self.delete_all_edges()
self.net.recalculate_edges()
self.draw_all_edges()
else:
self.f_auto_edge = False
self.show_btn_edge()
def show_radius(self, toggle):
if toggle.isChecked() == True:
self.f_show_radius = True
if self.last_pressed_node != 0 and self.option == 0:
self.draw_radius(self.last_pressed_node.get_X() + self.node_size/2, self.last_pressed_node.get_Y() + self.node_size/2, self.comm_range)
else:
self.f_show_radius = False
if self.radius != 0:
self.delete_radius()
def show_env(self, toggle):
if toggle.isChecked() == True:
self.f_show_env =True
if self.scene_env != 0:
self.scene_env.show()
else:
self.f_show_env = False
if self.scene_env != 0:
self.delete_env()
def draw_radius(self, x, y, comm_range):
self.radius = Radius(x, y, comm_range)
self.addItem(self.radius)
def delete_radius(self):
self.removeItem(self.radius)
self.radius = 0
# def search_node_by_id(self):
# f_found = False
#
# if self.last_pressed_node != 0:
# if self.last_pressed_node.node_id != self.spinId.value():
# self.last_pressed_node.setBrush(self.node_color)
# for n in self.items():
# if isinstance(n, Node):
# if n.node_id == self.spinId.value():
# if self.radius != 0 and self.f_show_radius:
# size = n.comm_range
# self.radius.setRect(n.get_X() - size, n.get_Y() - size, size * 2, size * 2)
# self.last_pressed_node = n
# n.setBrush(self.pressed_color)
# self.spinX.setValue(n.get_X())
# self.spinY.setValue(-n.get_Y())
# f_found = True
#
# if not f_found:
# self.last_pressed_node = 0
# self.spinX.setValue(0)
# self.spinY.setValue(0)
# if self.radius != 0:
# self.delete_radius()
def change_node_x(self):
if self.last_pressed_node != 0 and not self.f_move:
if self.last_pressed_node.get_X() != self.spinX.value():
self.spin_value_changed(True)
def change_node_y(self):
if self.last_pressed_node != 0 and not self.f_move:
if -self.last_pressed_node.get_Y() != self.spinY.value():
self.spin_value_changed(False)
def spin_value_changed(self, f_isX):
if not self.f_auto_edge:
self.move_edges(self.last_pressed_node, self.spinX.value(), self.spinY.value())
if self.f_auto_edge and not self.f_moved: #delete edges before node is moved
edges = list()
for edge in self.last_pressed_node.edges:
edges.append(edge)
for edge in edges:
self._delete_edge(edge, True)
if f_isX:
self.last_pressed_node.setX(self.spinX.value() - self.last_pressed_node.get_iniX())
self.last_pressed_node.node_label.setX(self.spinX.value())
else:
self.last_pressed_node.setY(-self.spinY.value() - self.last_pressed_node.get_iniY())
self.last_pressed_node.node_label.setY(-self.spinY.value())
net_node, n = self.get_nodes_from_net(self.last_pressed_node, 0)
self.net.pos[net_node] = [self.spinX.value(), self.spinY.value()]
if self.f_auto_edge and not self.f_moved:
self.net.recalculate_edges([self.last_pressed_node.net_node])
self.draw_recalc_edges(self.last_pressed_node.net_node)
def change_comm_range(self):
self.comm_range = self.spinCommRange.value()
if self.last_pressed_node != 0:
self.last_pressed_node.set_comm_range(self.comm_range)
net_node, n = self.get_nodes_from_net(self.last_pressed_node, 0)
net_node.commRange = self.comm_range
if self.radius != 0:
size = self.comm_range
self.radius.setRect(self.radius.get_iniX() - size, self.radius.get_iniY() - size, size * 2, size * 2)
def change_node_env_x(self):
self.envX = self.spinEnvX.value()
#TODO: dodati promjenu velicine env u net.env
self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY))
def change_node_env_y(self):
self.envY = self.spinEnvY.value()
#TODO: dodati promjenu velicine env u net.env
self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY))
def change_channel_type(self):
if self.comboChannelType.currentIndex() == 0:
self.net.channelType = pymote.channeltype.Udg(self.net.environment)
elif self.comboChannelType.currentIndex() == 1:
self.net.channelType = pymote.channeltype.SquareDisc(self.net.environment)
if not self.f_opening_net and self.f_auto_edge:
self.delete_all_edges()
self.net.recalculate_edges()
self.draw_all_edges()
def draw_net(self, net):
self.ini_scene()
self.net = net
self.f_opening_net = True
max_id = 0
for net_node in net:
node = self.draw_node(net.pos[net_node][0], net.pos[net_node][1], net_node.id, net_node.commRange, net_node)
self.net_dict[net_node] = node
if net_node.id > max_id:
max_id = net_node.id
self.curr_id = max_id + 1
self.draw_all_edges()
self.environment = net.environment
img = Image.fromarray(net.environment.im[::-1, :], 'L')
img.save('env.png')
self.draw_env('env.png')
combo_index = -1
if isinstance(net.channelType, pymote.channeltype.Udg):
combo_index = 0
elif isinstance(net.channelType, pymote.channeltype.SquareDisc):
combo_index = 1
self.comboChannelType.setCurrentIndex(combo_index)
self.f_opening_net = False
def draw_node(self, x, y, node_id, comm_range, net_node):
node_label = Label(str(node_id), x, -y)
self.addItem(node_label)
node = Node(x - self.node_size/2, -y - self.node_size/2, self.node_size, node_id, node_label, comm_range, net_node)
node.setBrush(self.node_color)
self.addItem(node)
return node
def draw_edge(self, node1, node2):
edge = Edge(node1, node2)
self.addItem(edge)
node1.add_edge_to_list(edge)
node2.add_edge_to_list(edge)
return edge
def draw_all_edges(self):
net = self.net
edges = list()
for net_node in self.net:
for n in net.adj[net_node].keys():
f_draw_edge = True
for e in edges: #check if edge already drawn
if (e[0] == net_node.id and e[1] == n.id) or (e[1] == net_node.id and e[0] == n.id):
f_draw_edge = False
if f_draw_edge:
node = self.net_dict[net_node]
adj_node = self.net_dict[n]
self.draw_edge(node, adj_node)
edges.append((net_node.id, n.id))
def delete_all_edges(self):
for item in self.items():
if isinstance(item, Edge):
self._delete_edge(item, True)
def draw_recalc_edges(self, net_node):
node = self.net_dict[net_node]
for n in self.net.adj[net_node].keys():
adj_node = self.net_dict[n]
self.draw_edge(node, adj_node)
def open_env(self):
filters = ['Environment image (*.png)', 'All files (*)']
selectedFilter = 'Environment image (*.png)'
filters = ';;'.join(filters)
fname = QFileDialog.getOpenFileName(
self.parent(), "Choose a file to open", '', filters, selectedFilter)
if fname:
try:
self.environment.__init__(path = str(fname))
self.net.environment = self.environment
self.draw_env(fname)
except Exception as e:
print ("Error opening file %s" % str(e)),
QMessageBox.critical(
self, "Error opening file", str(e),
QMessageBox.Ok, QMessageBox.NoButton)
def draw_env(self, image):
if self.scene_env == 0:
self.scene_env = QGraphicsPixmapItem()
else:
self.removeItem(self.scene_env)
self.scene_env.setPixmap(QPixmap(image))
if self.scene_env != 0:
self.scene_env.setPos(0, -self.environment.im.shape[1])
self.addItem(self.scene_env)
self.scene_env.setZValue(-1)
if not self.f_show_env:
self.scene_env.hide()
self.spinEnvX.setValue(self.environment.im.shape[0])
self.spinEnvY.setValue(self.environment.im.shape[1])
if self.f_auto_edge:
self.delete_all_edges()
self.net.recalculate_edges()
self.draw_all_edges()
def delete_env(self):
if self.scene_env != 0:
self.scene_env.hide()
def option_change(self):
if self.radius != 0:
self.delete_radius()
if self.edge_option != 0:
self.edge_option = 0
self.deselect_node()
if self.last_pressed_node != 0:
self.deselect_node()
def move_node(self):
self.option_change()
self.option = 0
def add_node(self):
self.option_change()
self.option = 1
def _add_node(self, x, y):
#add node to network
net_node = pymote.Node()
self.net.add_node(net_node, (x, y))
net_node.id = self.curr_id
net_node.commRange = self.comm_range
#add node to scene
node = self.draw_node(x, y, self.curr_id, self.comm_range, net_node)
self.net_dict[net_node] = node
self.curr_id = self.curr_id + 1
'''when adding new node to network pymote calls recalculate_edges,
if USE MODEL OF COMMUNICATON TO AUTO EDGES is not selected
then we need to remove those edges'''
if not self.f_auto_edge:
self.net.adj[net_node].clear()
for n in self.net:
if self.net.adj[n].has_key(net_node):
del self.net.adj[n][net_node]
else:
self.draw_recalc_edges(net_node)
def delete_node(self):
self.option_change()
self.option = 2
def _delete_node(self, node):
#delete node edges from scene
edges = list()
for edge in node.edges:
edges.append(edge)
for edge in edges:
self._delete_edge(edge, False)
self.removeItem(node)
self.removeItem(node.node_label)
#delete node from network
self.net.remove_node(node.net_node)
del self.net_dict[node.net_node]
def add_edge(self):
self.option_change()
self.option = 3
def _add_edge(self, pressed_node):
if pressed_node != 0:
if self.edge_option == 0:
self.select_node(pressed_node)
self.edge_option = 1
if self.edge_option == 1 and self.last_pressed_node != pressed_node and self.last_pressed_node != 0:
self.edge_option = 2
edge_exists = self.find_edge(pressed_node, self.last_pressed_node)
if edge_exists != 0:
self.edge_option = 0
self.deselect_node()
if self.edge_option == 2:
self.draw_edge(self.last_pressed_node, pressed_node)
self.edge_option = 0
#add edge to net.adj
node1, node2 = self.get_nodes_from_net(self.last_pressed_node, pressed_node)
if node1 != 0 and node2 != 0:
self.net.adj[node1][node2] = []
self.net.adj[node2][node1] = []
self.deselect_node()
elif pressed_node == 0 and self.edge_option == 1:
self.edge_option = 0
self.deselect_node()
def delete_edge(self):
self.option_change()
self.option = 4
def _delete_edge(self, edge, f_recal_called):
n1 = edge.node1
n2 = edge.node2
n1.remove_edge_from_list(edge)
n2.remove_edge_from_list(edge)
self.removeItem(edge)
#delete edge from net.adj
if not f_recal_called:
node1, node2 = self.get_nodes_from_net(n1, n2)
if node1 != 0 and node2 != 0:
self.delete_edge_from_adj(node1, node2)
self.delete_edge_from_adj(node2, node1)
def get_nodes_from_net(self, n1, n2):
node1 = 0
node2 = 0
for n in self.net:
if n.id == n1.node_id:
node1 = n
if n2 != 0:
if n.id == n2.node_id:
node2 = n
return (node1, node2)
def delete_edge_from_adj(self, node, del_n):
del self.net.adj[node][del_n]
def find_edge(self, node, n):
for e in node.edges:
if (n.get_X() == e.line().x1() and n.get_Y() == e.line().y1()) or (n.get_X() == e.line().x2() and n.get_Y() == e.line().y2()):
return e
return 0
def select_node(self, node):
self.last_pressed_node = node
node.setBrush(self.pressed_color)
if self.option == 0:
self.show_pressed_item_data()
if self.f_show_radius:
self.draw_radius(node.get_X() + self.node_size/2, node.get_Y() + self.node_size/2, self.last_pressed_node.comm_range)
def deselect_node(self):
self.last_pressed_node.setBrush(self.node_color)
self.last_pressed_node = 0
self.hide_pressed_item_data()
if self.radius != 0:
self.delete_radius()
def move_edges(self, node, x, y):
for edge in node.edges:
if edge.line().x1() == node.get_X() and edge.line().y1() == node.get_Y():
edge.setLine(x, y, edge.line().x2(), edge.line().y2())
else:
edge.setLine(edge.line().x1(), edge.line().y1(), x, y)
def mousePressEvent(self, e):
mouseX = e.scenePos().x()
mouseY = -e.scenePos().y()
pressed_node = 0
pressed_edge = 0
self.f_move = True
for item in self.items(e.scenePos()):
if pressed_node == 0 and isinstance(item, Node):
pressed_node = item
if pressed_edge == 0 and isinstance(item, Edge):
pressed_edge = item
#on new mouse press deselect last node (only if option add edge is not selected)
if self.last_pressed_node != 0:
if self.edge_option != 1:
self.deselect_node()
if self.option == 1: #draw node
self._add_node(mouseX, mouseY)
elif self.option == 2: #delete node
if pressed_node != 0:
self._delete_node(pressed_node)
elif self.option == 3: #add edge
self._add_edge(pressed_node)
elif self.option == 4: #delete edge
if pressed_edge != 0:
self._delete_edge(pressed_edge, False)
#select new pressed node and save it
if pressed_node != 0:
if self.option == 0:
self.select_node(pressed_node)
self.spinCommRange.setValue(pressed_node.comm_range)
else:
self.last_pressed_node = 0
def mouseMoveEvent(self, e):
mouseX = e.scenePos().x()
mouseY = e.scenePos().y()
self.lblXY.setText('x: ' + str(mouseX) + ' y: ' + str(-mouseY))
if self.last_pressed_node != 0 and self.f_move:
node = self.last_pressed_node
self.f_moved = True
if self.option == 0:
#when moving node, move his edges
if not self.f_auto_edge:
self.move_edges(node, mouseX, mouseY)
#move node
node.setX(mouseX - node.get_iniX())
node.setY(mouseY - node.get_iniY())
node.node_label.setPos(mouseX, mouseY)
net_node, n = self.get_nodes_from_net(node, 0)
self.net.pos[net_node][0] = mouseX
self.net.pos[net_node][1] = -mouseY
if self.f_auto_edge:
edges = list()
for edge in node.edges:
edges.append(edge)
for edge in edges:
self._delete_edge(edge, True)
self.spinX.setValue(mouseX)
self.spinY.setValue(-mouseY)
#move radius
if self.f_show_radius and (self.option == 1 or (self.option == 0 and self.last_pressed_node != 0 and self.f_move)):
if self.radius == 0 and self.option == 1:
self.draw_radius(mouseX, mouseY, self.comm_range)
elif self.radius != 0:
self.radius.setX(mouseX - self.radius.get_iniX())
self.radius.setY(mouseY - self.radius.get_iniY())
def mouseReleaseEvent(self, e):
if self.f_auto_edge and self.last_pressed_node != 0 and self.option == 0 and self.f_moved:
self.net.recalculate_edges([self.last_pressed_node.net_node])
self.draw_recalc_edges(self.last_pressed_node.net_node)
self.f_move = False
self.f_moved = False
class SlideshowFrame(object):
def __init__(self, win, rect, filename, metadata):
self.win = win
self.rect = rect
self.filename = filename
self.metadata = metadata
if self.metadata:
self.line1 = self.metadata['Name']
self.line2 = "%s Mission" % (self.metadata['Mission'])
self.line3 = "%s" % (self.metadata['Time'])
else:
self.line1 = ""
self.line2 = ""
self.line3 = ""
self.image = QGraphicsPixmapItem()
self.win.scene.addItem(self.image)
self.image.setTransformationMode(Qt.SmoothTransformation)
self.use_two_lines = True
self.fontsize1 = 32
self.fontsize2 = 26
self.fontsize3 = 24
self.font1 = QFont('Times New Roman', self.fontsize1)
self.font2 = QFont('Times New Roman', self.fontsize2)
self.font3 = QFont('Times New Roman', self.fontsize3)
self.title1 = self.win.scene.addText(self.line1, self.font1)
self.title1.setDefaultTextColor(Qt.white)
self.title1.setVisible(False)
self.title2 = self.win.scene.addText(self.line2, self.font2)
self.title2.setDefaultTextColor(Qt.white)
self.title2.setVisible(False)
self.title3 = self.win.scene.addText(self.line3, self.font3)
self.title3.setDefaultTextColor(Qt.white)
self.title3.setVisible(False)
self.reservedHeight = 128
self.padding = 20
self.hide()
def move(self, x, y):
self.rect = QRectF(x, y, self.rect.width(), self.rect.height())
def __rotate(self, metadata, origImgSize):
# Qt only handles orientation properly from v5.5
try:
# try directly to get the tag, because sometimes get_tags() returns
# tags that don't actually are in the file
rot = metadata['Exif.Image.Orientation']
except KeyError:
# guess :-/
rot = '1'
# see http://www.daveperrett.com/images/articles/2012-07-28-exif-orientation-handling-is-a-ghetto/EXIF_Orientations.jpg
# we have to 'undo' the rotations, so the numbers are negative
if rot == '1':
rotate = 0
imgSize = origImgSize
if rot == '8':
rotate = -90
imgSize = QSize(origImgSize.height(), origImgSize.width())
if rot == '3':
rotate = -180
imgSize = origImgSize
if rot == '6':
rotate = -270
imgSize = QSize(origImgSize.height(), origImgSize.width())
# undo the last rotation and apply the new one
self.image.setRotation(rotate)
return imgSize
def __zoomFit(self, imgSize):
reservedHeight = self.reservedHeight + self.padding * 2
hZoom = self.rect.width() / imgSize.width()
vZoom = (self.rect.height() - reservedHeight) / imgSize.height()
scale = min(hZoom, vZoom)
self.image.setScale(scale)
width = imgSize.width() * scale
height = imgSize.height() * scale
self.image.setPos(
(self.rect.width() - width) / 2 + self.rect.x(),
(self.rect.height() - reservedHeight - height) / 2 + self.rect.y())
def layoutText(self):
reservedHeight = self.reservedHeight + self.padding
vertical_spacing = (self.reservedHeight -
self.title1.boundingRect().height() -
self.title2.boundingRect().height() -
self.title3.boundingRect().height()) / 3
x = (self.rect.width() - self.title1.boundingRect().width()) / 2
y = self.rect.height() - reservedHeight + vertical_spacing
self.title1.setPos(x + self.rect.x(), y + self.rect.y())
x = (self.rect.width() - self.title2.boundingRect().width()) / 2
y = self.rect.height(
) - reservedHeight + vertical_spacing * 2 + self.title1.boundingRect(
).height()
self.title2.setPos(x + self.rect.x(), y + self.rect.y())
x = (self.rect.width() - self.title3.boundingRect().width()) / 2
y = self.rect.height(
) - reservedHeight + vertical_spacing * 3 + self.title1.boundingRect(
).height() + self.title2.boundingRect().height()
self.title3.setPos(x + self.rect.x(), y + self.rect.y())
def show(self):
img = QPixmap(self.filename)
try:
metadata = GExiv2.Metadata(self.filename)
except GLib.Error as e:
print(repr(e))
return
self.image.setPixmap(img)
self.image.setScale(1.0)
self.image.setRotation(0)
imgSize = self.__rotate(metadata, img.size())
self.__zoomFit(imgSize)
self.layoutText()
self.title1.setVisible(True)
self.title2.setVisible(True)
self.title3.setVisible(True)
self.image.setVisible(True)
def hide(self):
self.title1.setVisible(False)
self.title2.setVisible(False)
self.title3.setVisible(False)
self.image.setVisible(False)
self.image.setPixmap(QPixmap())
def showImage(self, file, md):
self.metadata = md
try:
metadata = GExiv2.Metadata(file)
except GLib.Error as e:
print(repr(e))
return
img = QPixmap(file)
self.image.setPixmap(img)
self.image.setScale(1.0)
self.image.setRotation(0)
imgSize = self.__rotate(metadata, img.size())
self.__zoomFit(imgSize)
self.layoutMetadata()
class EditLinksNode(QGraphicsWidget):
"""
A Node representation with channel anchors.
`direction` specifies the layout (default `Qt.LeftToRight` will
have icon on the left and channels on the right).
"""
def __init__(self,
parent=None,
direction=Qt.LeftToRight,
node=None,
icon=None,
iconSize=None,
**args):
QGraphicsWidget.__init__(self, parent, **args)
self.setAcceptedMouseButtons(Qt.NoButton)
self.__direction = direction
self.setLayout(QGraphicsLinearLayout(Qt.Horizontal))
# Set the maximum size, otherwise the layout can't grow beyond its
# sizeHint (and we need it to grow so the widget can grow and keep the
# contents centered vertically.
self.layout().setMaximumSize(QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX))
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__iconSize = iconSize or QSize(64, 64)
self.__icon = icon
self.__iconItem = QGraphicsPixmapItem(self)
self.__iconLayoutItem = GraphicsItemLayoutItem(item=self.__iconItem)
self.__channelLayout = QGraphicsGridLayout()
self.__channelAnchors = []
if self.__direction == Qt.LeftToRight:
self.layout().addItem(self.__iconLayoutItem)
self.layout().addItem(self.__channelLayout)
channel_alignemnt = Qt.AlignRight
else:
self.layout().addItem(self.__channelLayout)
self.layout().addItem(self.__iconLayoutItem)
channel_alignemnt = Qt.AlignLeft
self.layout().setAlignment(self.__iconLayoutItem, Qt.AlignCenter)
self.layout().setAlignment(self.__channelLayout,
Qt.AlignVCenter | channel_alignemnt)
if node is not None:
self.setSchemeNode(node)
def setIconSize(self, size):
"""
Set the icon size for the node.
"""
if size != self.__iconSize:
self.__iconSize = QSize(size)
if self.__icon:
self.__iconItem.setPixmap(self.__icon.pixmap(size))
self.__iconLayoutItem.updateGeometry()
def iconSize(self):
"""
Return the icon size.
"""
return QSize(self.__iconSize)
def setIcon(self, icon):
"""
Set the icon to display.
"""
if icon != self.__icon:
self.__icon = QIcon(icon)
self.__iconItem.setPixmap(icon.pixmap(self.iconSize()))
self.__iconLayoutItem.updateGeometry()
def icon(self):
"""
Return the icon.
"""
return QIcon(self.__icon)
def setSchemeNode(self, node):
"""
Set an instance of `SchemeNode`. The widget will be initialized
with its icon and channels.
"""
self.node = node
if self.__direction == Qt.LeftToRight:
channels = node.output_channels()
else:
channels = node.input_channels()
self.channels = channels
loader = icon_loader.from_description(node.description)
icon = loader.get(node.description.icon)
self.setIcon(icon)
label_template = ('<div align="{align}">'
'<b class="channelname">{name}</b><br/>'
'<span class="typename">{typename}</span>'
'</div>')
if self.__direction == Qt.LeftToRight:
align = "right"
label_alignment = Qt.AlignVCenter | Qt.AlignRight
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 0
anchor_row = 1
else:
align = "left"
label_alignment = Qt.AlignVCenter | Qt.AlignLeft
anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft
label_row = 1
anchor_row = 0
self.__channelAnchors = []
grid = self.__channelLayout
for i, channel in enumerate(channels):
text = label_template.format(align=align,
name=escape(channel.name),
typename=escape(channel.type))
text_item = GraphicsTextWidget(self)
text_item.setHtml(text)
text_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
grid.addItem(text_item, i, label_row, alignment=label_alignment)
anchor = ChannelAnchor(self,
channel=channel,
rect=QRectF(0, 0, 20, 20))
anchor.setBrush(self.palette().brush(QPalette.Mid))
layout_item = GraphicsItemLayoutItem(grid, item=anchor)
grid.addItem(layout_item,
i,
anchor_row,
alignment=anchor_alignment)
if hasattr(channel, "description"):
text_item.setToolTip((channel.description))
self.__channelAnchors.append(anchor)
def anchor(self, channel):
"""
Return the anchor item for the `channel` name.
"""
for anchor in self.__channelAnchors:
if anchor.channel() == channel:
return anchor
raise ValueError(channel.name)
def paint(self, painter, option, widget=None):
painter.save()
palette = self.palette()
border = palette.brush(QPalette.Mid)
pen = QPen(border, 1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.setBrush(palette.brush(QPalette.Window))
brect = self.boundingRect()
painter.drawRoundedRect(brect, 4, 4)
painter.restore()
