def adjust(self):
if self.__source:
self.beginCp.setVisible(False)
line1 = QLineF(self.mapFromItem(self.__source, 0, 0), self._edge1)
length1 = line1.length()
if length1 > 20.0:
edgeOffset = QPointF(line1.dx() * 10 / length1,
line1.dy() * 10 / length1)
self.__sourcePoint = line1.p1() + edgeOffset
else:
self.__sourcePoint = line1.p1()
else:
self.beginCp.setVisible(True)
self.beginCp.setPoint(self.__sourcePoint)
if self.__dest:
self.endCp.setVisible(False)
line2 = QLineF(self.mapFromItem(self.__dest, 0, 0), self._edge2)
length2 = line2.length()
if length2 > 20.0:
edgeOffset = QPointF(line2.dx() * 10 / length2,
line2.dy() * 10 / length2)
if self._isDigraph:
self.__destPoint = line2.p1() + edgeOffset * 2.3
else:
self.__destPoint = line2.p1() + edgeOffset
else:
self.__destPoint = line2.p1()
else:
self.endCp.setVisible(True)
self.endCp.setPoint(self.__destPoint)
self.prepareGeometryChange()
def add_door_right(room_, side_):
line = QLineF(room_.topRight(), room_.bottomRight())
line_lenght = int(line.length())
step = line_lenght / 100.
line_points = []
for t in np.arange(0.25, 0.75, step):
line_point = line.pointAt(t)
line_points.append(QPointF(line_point.x(), line_point.y()))
random_center_door = random.choice(line_points)
left_door = QPointF(random_center_door.x(), random_center_door.y() - 0.5)
right_door = QPointF(random_center_door.x(), random_center_door.y() + 0.5)
if side_ == 'bottom':
polygon = QPolygonF([
right_door,
room_.topRight(),
room_.topLeft(),
room_.bottomLeft(),
room_.bottomRight(), left_door
])
elif side_ == 'top':
polygon = QPolygonF([
right_door,
room_.bottomRight(),
room_.bottomLeft(),
room_.topLeft(),
room_.topRight(), left_door
])
return polygon
def add_door_center(room_):
line = QLineF(room_.topLeft(), room_.topRight())
line_lenght = int(
line.length()
) # -1 sin pasillo, 0 antes de la primera habitacion, 1 antes de la segunda
step = line_lenght / 100.
line_points = []
for t in np.arange(0.25, 0.75, step):
line_point = line.pointAt(t)
line_points.append(QPointF(line_point.x(), line_point.y()))
random_center_door = random.choice(line_points)
left_door = QPointF(random_center_door.x() - 0.5, random_center_door.y())
right_door = QPointF(random_center_door.x() + 0.5, random_center_door.y())
polygon = QPolygonF([
right_door,
room_.topRight(),
room_.bottomRight(),
room_.bottomLeft(),
room_.topLeft(), left_door
])
return polygon
def try_to_append_point(self, p_abs):
p: QPointF = p_abs - self.pos()
if len(self.points) > 0:
line = QLineF(self.points[-1], p)
if line.length() < 0.5:
return False
self.points.append(p)
return True
def append_point(self, posF_in_view: QPointF) -> bool:
"""Only used for active drawing.
Appends a point (floating, in viewport coordinates),
if the distance to the last one isn't oo small"""
p: QPointF = (self.viewport_pos + posF_in_view) - self.pos()
if len(self.points) > 0:
line = QLineF(self.points[-1], p)
if line.length() < 0.5:
return False
self.points.append(p)
return True
def try_to_append_point(self, p_abs):
# p: QPointF = self.mapToScene(self.pos()) + (p_viewport-self.pos())
# print('---------------------------')
# print(p)
# print(p_viewport)
# print(self.pos())
# print(self.mapToScene(self.pos()))
# print('---------------------------')
p: QPointF = p_abs - self.pos()
if len(self.points) > 0:
line = QLineF(self.points[-1], p)
if line.length() < 0.5:
return False
self.points.append(p)
return True
def paint(self, painter, option, widget):
pen = QPen()
pen.setColor(QColor(150, 150, 150))
pen.setWidth(1)
painter.setPen(pen)
if not self._fromNode() or not self._toNode():
return
line = QLineF(self.fromPoint, self.toPoint)
if line.length() == 0.0:
return
# self.drawArc(painter, line)
topLeftPoint = self.calculatePerpendicularPoint(
self.fromPoint, 50, line)
arcRect = QRectF(topLeftPoint, QSizeF(line.length(), 100))
if self._fromNode is self._toNode:
spanAngle = -360
else:
spanAngle = -180
# painter.drawArc(arcRect, 0, spanAngle)
colliding = self.collidingItems()
if len(colliding) > 0:
line.setP1(line.p1() + QPointF(10, 10))
line.setP2(line.p2() + QPointF(10, 10))
line.translate(10, 10)
painter.drawLine(line)
midpoint = QPointF(line.center().x(), line.center().y())
labelCenterPoint = self.calculatePerpendicularPoint(midpoint, 75, line)
self.labelBox.setPos(labelCenterPoint)
angle = math.acos(line.dx() / line.length())
self.drawArrowHead(painter, angle, line.p2())
def reverseStandardData(self, excelData):
graphName = excelData[0]
mode = excelData[1]
nodes = []
edges = []
texts = []
self.ui.actionDigraph_Mode.setChecked(bool(mode))
for nodeDetail in excelData[2]:
node = BezierNode()
node.textCp.setPlainText(f"V{nodeDetail[0]}")
node.setData(self.__ItemId, nodeDetail[0])
nodeText = self._tr("MainWindow", "顶点")
node.setData(self.__ItemDesc, nodeText)
if len(nodeDetail) < 3:
for i in range(2):
intRandom = randint(-400, 400)
nodeDetail.append(intRandom)
node.setPos(QPointF(nodeDetail[2], nodeDetail[3]))
node.weightCp.setPlainText(str(nodeDetail[1]))
nodes.append(node)
for edgeDetail in excelData[3]:
edge = BezierEdge()
edge.setData(self.__ItemId, edgeDetail[0])
edge.setData(self.__ItemDesc, "边")
edge.textCp.setPlainText(f"e{edgeDetail[0]}")
edge.weightCp.setPlainText(str(edgeDetail[3]))
if len(edgeDetail) <= 4:
for i in range(10):
intRandom = randint(-400, 400)
edgeDetail.append(intRandom)
edge.setPos(QPointF(edgeDetail[12], edgeDetail[13]))
if edgeDetail[1] >= 0:
for node in nodes:
node: BezierNode
if node.data(self.__ItemId) == edgeDetail[1]:
edge.setSourceNode(node)
node.addBezierEdge(edge, ItemType.SourceType)
line = QLineF(edge.mapFromScene(node.pos()),
edge.edge1Cp.point())
length = line.length()
edgeOffset = QPointF(line.dx() * 10 / length,
line.dy() * 10 / length)
source = edge.mapFromScene(node.pos()) + edgeOffset
edge.setSpecialControlPoint(source,
ItemType.SourceType)
edge.beginCp.setVisible(False)
else:
edge.setSpecialControlPoint(
QPointF(edgeDetail[4], edgeDetail[5]), ItemType.SourceType)
if edgeDetail[2] >= 0:
for node in nodes:
node: BezierNode
if node.data(self.__ItemId) == edgeDetail[2]:
edge.setDestNode(node)
node.addBezierEdge(edge, ItemType.DestType)
line = QLineF(edge.mapFromScene(node.pos()),
edge.edge2Cp.point())
length = line.length()
edgeOffset = QPointF(line.dx() * 10 / length,
line.dy() * 10 / length)
if mode:
dest = edge.mapFromScene(
node.pos()) + edgeOffset * 2.3
else:
dest = edge.mapFromScene(node.pos()) + edgeOffset
edge.setSpecialControlPoint(dest, ItemType.DestType)
edge.endCp.setVisible(False)
else:
edge.setSpecialControlPoint(
QPointF(edgeDetail[10], edgeDetail[11]), ItemType.DestType)
edge.setEdgeControlPoint(QPointF(edgeDetail[6], edgeDetail[7]),
ItemType.SourceType)
edge.setEdgeControlPoint(QPointF(edgeDetail[8], edgeDetail[9]),
ItemType.DestType)
edge.centerCp.setPoint(edge.updateCenterPos())
edges.append(edge)
if len(excelData) <= 4:
return [graphName, nodes + edges]
for textDetail in excelData[4]:
text = BezierText(str(textDetail[1]))
text.setData(self.__ItemId, textDetail[0])
text.setData(self.__ItemDesc, "文本")
text.setPos(textDetail[2], textDetail[3])
texts.append(text)
return [graphName, nodes + edges + texts]
initial_corridor_interior.bottomRight()
],
'top': [
initial_corridor_interior.bottomLeft(),
initial_corridor_interior.bottomRight()
],
'left': [
initial_corridor_interior.bottomLeft(),
initial_corridor_interior.topLeft()
]
}
# -------- Recorro el pasillo inicial buscando puntos a lo largo de su perimetro -----------
for side, points in corridor_sides.items():
line = QLineF(points[0], points[1])
line_lenght = int(line.length())
step = line_lenght / 100.
for t in np.arange(
0.20, 0.80, step
): # intento evitar las esquinas empezando en 0.2 y acabando en 0.8
line_point = line.pointAt(t)
corridor_points[side].append(QPointF(line_point.x(), line_point.y()))
max_rooms_per_side = math.ceil(num_rooms / 2)
# Dividir la lista de puntos en secciones dependiendo del numero de habitaciones para escoger puntos de esa seccion --- Darle una vuelta
# for side, list_points in corridor_points.items():
# corridor_points[side] = [list_points[i::max_rooms_per_side] for i in np.arange(max_rooms_per_side)]
def try_to_append_point(self, p):
if len(self.points) > 0:
line = QLineF(self.points[-1], p)
if line.length() < 1.5:
return
self.points.append(p)
