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 paintLimits(self, painter, limit, rect):
hh = int(rect.height() / 2)
posFo = QPolygonF(
[QPointF(s, (f * hh) + hh + 2) for s, f in enumerate(limit)])
negFo = QPolygonF(
[QPointF(s, (-f * hh) + hh - 2) for s, f in enumerate(limit)])
painter.save()
painter.setPen(QPen(self.limitColor, 2))
painter.drawPolyline(posFo)
painter.drawPolyline(negFo)
painter.restore()
def compute_circle_arc_polygon(self,
x0,
y0,
radius,
phi_begin,
arc_length,
steps=32):
polygon = QPolygonF()
x0_t, y0_t = self.convert_position(x0, y0)
polygon.append(QPointF(x0_t, y0_t))
begin = phi_begin
end = arc_length + phi_begin
step = (begin - end) / steps
angle = float(begin)
for i in range(steps):
x = x0 + radius * numpy.cos(angle)
y = y0 + radius * numpy.sin(angle)
x_t, y_t = self.convert_position(x, y)
polygon.append(QPointF(x_t, y_t))
angle += step
return polygon
def _generate_indicators(self, **kwargs): # pylint: disable=unused-argument
"""
Paint arrow indicators of selected instructions and labels.
"""
scene = self.scene()
for item in self._map_indicator_items:
scene.removeItem(item)
self._map_indicator_items.clear()
for addr in list(self.disasm_view.infodock.selected_insns) + list(
self.disasm_view.infodock.selected_labels):
pos = self._get_pos_from_addr(addr)
if pos is None:
continue
pos -= 1 # this is the top-left x coordinate of our arrow body (the rectangle)
pen = QPen(Qt.yellow)
brush = QBrush(Qt.yellow)
item = QGraphicsRectItem(QRectF(pos, 0, 2, 10), parent=self)
item.setPen(pen)
item.setBrush(brush)
item.setZValue(self.ZVALUE_INDICATOR)
self._map_indicator_items.append(item)
triangle = QPolygonF()
triangle.append(QPointF(pos - 1, 10))
triangle.append(QPointF(pos + 3, 10))
triangle.append(QPointF(pos + 1, 12))
triangle.append(QPointF(pos - 1, 10))
item = QGraphicsPolygonItem(triangle, parent=self)
item.setPen(pen)
item.setBrush(brush)
item.setZValue(self.ZVALUE_INDICATOR)
self._map_indicator_items.append(item)
def newLoadData(self, threadName, timestamps, load):
"""
Slot called when new load data is available
:param threadName: the name of the thread given as string
:param loadData: the load data, given as the QByteArray of a n x 2 np.float32 array
:return:
"""
atimestamps = np.frombuffer(memoryview(timestamps), dtype=np.int64)
aload = np.frombuffer(memoryview(load), dtype=np.float32)
if LoadDisplayWidget.baseTimestamp is None:
LoadDisplayWidget.baseTimestamp = np.min(atimestamps)
if threadName not in self._loadData:
self._loadData[threadName] = QPolygonF()
p = self._loadData[threadName]
for i in range(aload.shape[0]):
x = 1e-9 * (atimestamps[i] - self.baseTimestamp)
if p.size() > 0 and p.at(p.count() - 1).x() > x:
# it seems that QT re-orders slots :( we have to maintain the order here
idx = p.count()
while idx > 0 and p.at(idx - 1).x() > x:
idx -= 1
p.insert(idx, QPointF(x, aload[i]))
else:
p.append(QPointF(x, aload[i]))
if p[p.count() - 1].x() - p[0].x() > 60:
for i in range(p.count()):
if p[p.count() - 1].x() - p[i].x() <= 60:
p.remove(0, i)
break
self.update()
def center_apartment(self):
union_polygon = QPolygonF()
for list in self.dict_rooms_and_corridors_per_side.values():
for room in list:
union_polygon = union_polygon.united(
room.room_qpolygon) # Para obtener el bounding box
self.total_rooms_and_corridors.append(room)
self.initial_corridor.setLeft(union_polygon.boundingRect().left())
self.initial_corridor.setRight(union_polygon.boundingRect().right())
self.total_rooms_and_corridors.append(
Room(type='corridor',
p=self.initial_corridor.topLeft(),
w=self.initial_corridor.width(),
h=self.initial_corridor.height()))
union_polygon = union_polygon.united(self.initial_corridor)
initial_center = union_polygon.boundingRect().center()
union_polygon.translate(-initial_center)
self.apartment_boundingRect = union_polygon.boundingRect()
# Desplazo habitaciones y pasillos al centro
for i, room in enumerate(self.total_rooms_and_corridors):
room.room_qpolygon.translate(
-initial_center
) # Desplazo los poligonos para que la habitación esté centrada
room.room_qrect.translate(-initial_center)
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 updatePath(self):
axeSize = self.size
yZero = self.yZero
try:
X = []
for item in self.fixedPoints:
X.extend([item.B.x() + item.x(), item.C.x() + item.x()])
X = np.array(X)
Y = np.array(
[-(item.A.y() + item.y())
for item in self.fixedPoints]) + yZero
T = displacementSpline(X,
Y,
self.xCoords,
clippingInterval=[-self.scene().axeSize, 0],
period=self.period)
self.spline = [
QPointF(x, y + yZero) for x, y in zip(self.xCoords, -T)
] # scene coord.
# build path
polygon = QPolygonF(self.spline)
qpp = QPainterPath()
qpp.addPolygon(polygon)
# stroke path
stroker = QPainterPathStroker()
stroker.setWidth(self.strokeWidth)
mboundingPath = stroker.createStroke(qpp)
self.setPath(mboundingPath)
except ValueError:
pass
def _paint_insn_indicators(self):
scene = self.view.scene() # type: QGraphicsScene
for item in self._insn_indicators:
scene.removeItem(item)
self._insn_indicators.clear()
for selected_insn_addr in self.disasm_view.infodock.selected_insns:
pos = self._get_pos_from_addr(selected_insn_addr)
if pos is None:
continue
pos -= 1 # this is the top-left x coordinate of our arrow body (the rectangle)
pen = QPen(Qt.yellow)
brush = QBrush(Qt.yellow)
rect = QRectF(pos, 0, 2, 5)
# rectangle
item = scene.addRect(rect, pen, brush)
self._insn_indicators.append(item)
# triangle
triangle = QPolygonF()
triangle.append(QPointF(pos - 1, 5))
triangle.append(QPointF(pos + 3, 5))
triangle.append(QPointF(pos + 1, 7))
triangle.append(QPointF(pos - 1, 5))
item = scene.addPolygon(triangle, pen, brush)
self._insn_indicators.append(item)
def setUp(self):
#Acquire resources
super(QColorOnSetBrush, self).setUp()
self.scene = QGraphicsScene()
poly = QPolygonF()
self.item = self.scene.addPolygon(poly)
self.color = QColor('black')
def beforeTest(self):
points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
pol = self.scene.addPolygon(QPolygonF(points))
self.assert_(isinstance(pol, QGraphicsPolygonItem))
self.wrp = weakref.ref(pol, pol_del)
#refcount need be 3 because one ref for QGraphicsScene, and one to rect obj
self.assertEqual(sys.getrefcount(pol), 3)
def createPoly(self, n, r, s):
polygon = QPolygonF()
w = 360/n # angle per step
for i in range(n): # add the points of polygon
t = w*i + s
x = r*math.cos(math.radians(t))
y = r*math.sin(math.radians(t))
polygon.append(QtCore.QPointF(self.w/2 +x, self.h/2 + y))
def __init__(self, starCount=1, maxStarCount=5):
self.starCount = starCount
self.maxStarCount = maxStarCount
# Create the star shape we'll be drawing.
self.starPolygon = QPolygonF()
self.starPolygon.append(QPointF(1.0, 0.5))
for i in range(1, 5):
self.starPolygon.append(QPointF(0.5 + 0.5 * cos(0.8 * i * pi),
0.5 + 0.5 * sin(0.8 * i * pi)))
# Create the diamond shape we'll show in the editor
self.diamondPolygon = QPolygonF()
diamondPoints = [QPointF(0.4, 0.5), QPointF(0.5, 0.4),
QPointF(0.6, 0.5), QPointF(0.5, 0.6),
QPointF(0.4, 0.5)]
self.diamondPolygon.append(diamondPoints)
def paintWaves(self, painter, waves, rect):
hh = int(rect.height() / 2)
curve = QPolygonF(
[QPointF(s, (-f * hh) + hh) for s, f in enumerate(waves)])
painter.save()
painter.setPen(QPen(self.waveColor, 2))
painter.drawPolyline(curve)
painter.restore()
def draw_shapely_poly(self, scene: QGraphicsScene, poly: Polygon,
pen: QPen, brush: QBrush) -> Optional[QPolygonF]:
if poly.is_empty:
return None
points = []
for x, y in poly.exterior.coords:
x, y = self._transform_point(Point(x, y))
points.append(QPointF(x, y))
return scene.addPolygon(QPolygonF(points), pen, brush)
def updatePath(self, calculate=True):
"""
Calculates (if calculate=true) and displays the spline.
Called by activePoint and activeTangent mouse event
@param calculate:
@type calculate: bool
"""
# calculate the array of slopes
d = [
item.controlPoint - item.contactPoint
for item in self.fixedTangents
]
d1 = -np.array(list(map(lambda a: a.y(), d)))
d2 = np.array(list(map(lambda a: a.x(), d)))
d = d1 / d2
# add boundary points if needed
X = [item.x() for item in self.fixedPoints]
Y = [item.y() for item in self.fixedPoints]
X0, X1 = X[0], X[-1]
Y0, Y1 = Y[0], Y[-1]
t = (Y1 - Y0) / (X1 - X0)
Y2 = Y0 - X0 * t
Y3 = Y0 + (self.size - X0) * t
d = d.tolist()
if X[0] > 0.0:
X.insert(0, 0.0)
Y.insert(0, Y2)
d.insert(0, t)
if X[-1] < self.size:
X.append(self.size)
Y.append(Y3)
d.append(t)
d = np.array(d)
try:
if calculate:
T = interpolationQuadSpline(
np.array(X) / self.size, -np.array(Y) / self.size,
d) * self.size
self.spline = [
QPointF(x, y)
for x, y in zip(np.arange(256) * (self.size / 255.0), -T)
]
for P in self.spline:
if P.x() < X0:
P.setY(Y0)
elif P.x() > X1:
P.setY(Y1)
polygon = QPolygonF(self.spline)
qpp = QPainterPath()
qpp.addPolygon(polygon)
# stroke path
stroker = QPainterPathStroker()
stroker.setWidth(self.strokeWidth)
mboundingPath = stroker.createStroke(qpp)
self.setPath(mboundingPath)
except Exception as e:
print(str(e))
def create_room(self):
print(
f'Creating room of type {self.type} with width = {self.width} and height = {self.height}'
)
self.room_qrect = QRectF(self.initial_point.x(),
self.initial_point.y(), self.width,
self.height)
self.room_qpolygon = QPolygonF(self.room_qrect)
self.area = abs(self.width * self.height)
def getFrozenQuad(self):
"""
Returns the starting quad for the current type of transformation
@return:
@rtype: QPolygonF
"""
poly = QPolygonF()
for role in ['topLeft', 'topRight', 'bottomRight', 'bottomLeft']:
poly.append(self.btnDict[role].posRelImg_frozen)
return poly
def getSourceQuad(self):
"""
Returns the starting quad for the transformation in progress
@return:
@rtype: QPolygonF
"""
poly = QPolygonF()
for role in ['topLeft', 'topRight', 'bottomRight', 'bottomLeft']:
poly.append(self.btnDict[role].posRelImg_ori)
return poly
def __init__(self, type='genericRoom', p=QPointF(), w=-1, h=-1):
self.type = type # corridor, bedroom, kitchen, bathroom, etc
self.width = w
self.height = h
self.initial_point = p
self.room_qrect = QRectF()
self.room_qpolygon = QPolygonF()
self.area = -1
self.door_position = None
self.create_room()
def getTargetQuad(self):
"""
Returns the current quad, as defined by the 4 buttons.
Coordinates are relative to the full size image
@return:
@rtype: QPolygonF
"""
poly = QPolygonF()
for role in ['topLeft', 'topRight', 'bottomRight', 'bottomLeft']:
poly.append(self.btnDict[role].posRelImg)
return poly
def addBackground(self):
scene = self.scene()
if not DisplayOptions.map_poly:
bg = QPixmap("./resources/" + self.game.theater.overview_image)
scene.addPixmap(bg)
# Apply graphical effects to simulate current daytime
if self.game.current_turn_time_of_day == TimeOfDay.Day:
pass
elif self.game.current_turn_time_of_day == TimeOfDay.Night:
ov = QPixmap(bg.width(), bg.height())
ov.fill(CONST.COLORS["night_overlay"])
overlay = scene.addPixmap(ov)
effect = QGraphicsOpacityEffect()
effect.setOpacity(0.7)
overlay.setGraphicsEffect(effect)
else:
ov = QPixmap(bg.width(), bg.height())
ov.fill(CONST.COLORS["dawn_dust_overlay"])
overlay = scene.addPixmap(ov)
effect = QGraphicsOpacityEffect()
effect.setOpacity(0.3)
overlay.setGraphicsEffect(effect)
else:
# Polygon display mode
if self.game.theater.landmap is not None:
for sea_zone in self.game.theater.landmap[2]:
print(sea_zone)
poly = QPolygonF([QPointF(*self._transform_point(Point(point[0], point[1]))) for point in sea_zone])
scene.addPolygon(poly, CONST.COLORS["sea_blue"], CONST.COLORS["sea_blue"])
for inclusion_zone in self.game.theater.landmap[0]:
poly = QPolygonF([QPointF(*self._transform_point(Point(point[0], point[1]))) for point in inclusion_zone])
scene.addPolygon(poly, CONST.COLORS["grey"], CONST.COLORS["dark_grey"])
for exclusion_zone in self.game.theater.landmap[1]:
poly = QPolygonF([QPointF(*self._transform_point(Point(point[0], point[1]))) for point in exclusion_zone])
scene.addPolygon(poly, CONST.COLORS["grey"], CONST.COLORS["dark_dark_grey"])
def paintEngine(self):
myGradient = QLinearGradient()
myPen = QPen()
myPolygon = QPolygonF()
myPath = QPainterPath()
myPath.addPolygon(myPolygon)
painter = QPainter()
painter.setBrush(myGradient)
painter.setPen(myPen)
painter.drawPath(myPath)
def drawArrow(self):
line = QLineF(self._edge2, self.__destPoint)
v = line.unitVector()
v.setLength(12)
v.translate(QPointF(line.dx(), line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
return QPolygonF([p1, p2, p3, p1])
def __init__(self, type='genericRoom', p=QPointF(), w=-1, h=-1):
self.type = type # corridor, bedroom, kitchen, bathroom, etc
self.width = w
self.height = h
self.initial_point = p
self.room_qrect = QRectF()
self.room_qpolygon = QPolygonF()
self.area = -1
self.side = None
self.door_loc = -1 # 0 entre topL y topR, 1 entre topR y bottomR, 2 entre bottomR y bottomL y 3 entr bL y tL
self.create_room()
def testquadToQuad(self):
q1 = QPolygonF()
q1.append(QPointF(10.0, 10.0))
q1.append(QPointF(20.0, 10.0))
q1.append(QPointF(10.0, -10.0))
q1.append(QPointF(20.0, -10.0))
q2 = QPolygonF()
q2.append(QPointF(20.0, 20.0))
q2.append(QPointF(30.0, 20.0))
q2.append(QPointF(20.0, -20.0))
q2.append(QPointF(30.0, -20.0))
t1 = QTransform()
r1 = QTransform.quadToQuad(q1, q2, t1)
r2 = QTransform.quadToQuad(q1, q2)
self.assertTrue(r1)
self.assertTrue(r2)
self.assertEqual(t1, r2)
def getNewWindow(cls, targetImage=None, axeSize=500, layer=None, parent=None, curveType='quadric'):
newWindow = graphicsToneForm(targetImage=targetImage, axeSize=axeSize, layer=layer, parent=parent, curveType=curveType)
newWindow.setWindowTitle(layer.name)
# init marker
triangle = QPolygonF()
s = 10
triangle.append(QPointF(-s, s))
triangle.append(QPointF(0, 0))
triangle.append(QPointF(s, s))
newWindow.inputMarker = QGraphicsPolygonItem(triangle)
newWindow.scene().addItem(newWindow.inputMarker)
newWindow.inputMarker.setBrush(QBrush(Qt.white))
return newWindow
def testIt(self):
points = []
for i in range(0, 4):
points.append(QPointF(float(i), float(i)))
p = QPolygonF(points)
self.assertEqual(len(p), 4)
i = 0
for point in p:
self.assertEqual(int(point.x()), i)
self.assertEqual(int(point.y()), i)
i += 1
def testsquareToQuad(self):
q1 = QPolygonF()
q1.append(QPointF(10.0, 10.0))
q1.append(QPointF(20.0, 10.0))
q1.append(QPointF(10.0, -10.0))
q1.append(QPointF(20.0, -10.0))
t1 = QTransform()
r1 = QTransform.squareToQuad(q1, t1)
r2 = QTransform.squareToQuad(q1)
self.assertTrue(r1)
self.assertTrue(r2)
self.assertEqual(t1, r2)
def __init__(self, auto_scroll_row: int, level: Level):
self.auto_scroll_row = auto_scroll_row
self.level = level
self.current_pos = QPointF()
self.horizontal_speed = 0
self.vertical_speed = 0
self.rom = ROM()
self.pixel_length = 1
self.acceleration_pen = Qt.NoPen
self.acceleration_brush = Qt.NoBrush
self.scroll_pen = Qt.NoPen
self.scroll_brush = Qt.NoBrush
self.screen_polygon = QPolygonF()
