def _init_env(self):
self.camera_pst = QPoint(self.width() // 2, self.height() // 2)
def testPolygonShiftOperators(self):
p = QPolygon()
self.assertEqual(len(p), 0)
p << QPoint(10, 20) << QPoint(
20, 30) << [QPoint(20, 30), QPoint(40, 50)]
self.assertEqual(len(p), 4)
def mousePressEvent(self, event):
self.lastPos = QPoint(event.pos())
def advance(self, phase):
if not self.phase:
return
location = QPoint(self.pos())
self.setPos(self.mapToParent(0, -speed))
def testMatrix(self):
matrix = QMatrix(11, 12, 21, 22, 100, 200)
point = QPoint(3, 3)
self.assertEqual(point * matrix, qpointTimesQMatrix(point, matrix))
def point(self) -> QPoint:
return QPoint(self.column * self.maze.paintStep, self.row * self.maze.paintStep)
def testMatrixWithWrongType(self):
matrix = QMatrix(11, 12, 21, 22, 100, 200)
point = QPoint(3, 3)
# This exception may move from a TypeError to a ValueError.
self.assertRaises((TypeError, ValueError), matrix.__mul__, point)
def point_on_image(self, e):
x_offset, y_offset = self.__image_offset()
pos = QPoint(e.x() - x_offset, e.y() - y_offset)
return pos
def paintEvent(self, event):
p = QPainter()
p.begin(self)
self._normalMap.render(p, event.rect())
p.setPen(Qt.black)
# p.drawText(self.rect(), Qt.AlignBottom | Qt.TextWordWrap, "Map data CCBYSA 2009 OpenStreetMap.org contributors")
p.end()
if self.zoomed:
dim = min(self.width(), self.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
# reupdate our mask
if self.maskPixmap.size() != box:
self.maskPixmap = QPixmap(box)
self.maskPixmap.fill(Qt.transparent)
g = QRadialGradient()
g.setCenter(radius, radius)
g.setFocalPoint(radius, radius)
g.setRadius(radius)
g.setColorAt(1.0, QColor(255, 255, 255, 0))
g.setColorAt(0.5, QColor(128, 128, 128, 255))
mask = QPainter(self.maskPixmap)
mask.setRenderHint(QPainter.Antialiasing)
mask.setCompositionMode(QPainter.CompositionMode_Source)
mask.setBrush(g)
mask.setPen(Qt.NoPen)
mask.drawRect(self.maskPixmap.rect())
mask.setBrush(QColor(Qt.transparent))
mask.drawEllipse(g.center(), ring, ring)
mask.end()
center = self.dragPos - QPoint(0, radius)
center += QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * 2 - QPoint(radius, radius)
# only set the dimension to the magnified portion
if self.zoomPixmap.size() != box:
self.zoomPixmap = QPixmap(box)
self.zoomPixmap.fill(Qt.lightGray)
if True:
p = QPainter(self.zoomPixmap)
p.translate(-xy)
self._largeMap.render(p, QRect(xy, box))
p.end()
clipPath = QPainterPath()
clipPath.addEllipse(QPointF(center), ring, ring)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
p.setClipPath(clipPath)
p.drawPixmap(corner, self.zoomPixmap)
p.setClipping(False)
p.drawPixmap(corner, self.maskPixmap)
p.setPen(Qt.gray)
p.drawPath(clipPath)
if self.invert:
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_Difference)
p.fillRect(event.rect(), Qt.white)
p.end()
def pixmap(self, size=QSize(512, 512), mode=None, state=None):
pm = QPixmap(size)
pm.fill(Qt.transparent)
self.paint(QPainter(pm), QRect(QPoint(0, 0), size), mode, state)
return pm
def pos(self) -> QPoint:
"""Return the cell's grid position as a QPoint."""
return QPoint(self._pos)
def contextMenuEvent(self, event):
"""
context menu handler
@param event
@type event: QContextMenuEvent
"""
selection = self.selectedIndexes()
if not selection:
return
# get a fresh context menu without connected actions
# and with state corresponding to the currently clicked layer
self.cMenu = self.initContextMenu()
# get current selection
rows = set([mi.row() for mi in selection])
rStack = self.img.layersStack[::-1]
layers = [rStack[r] for r in rows]
# get current position
index = self.indexAt(event.pos())
layerStackIndex = len(self.img.layersStack) - 1 - index.row()
layer = self.img.layersStack[layerStackIndex]
lowerVisible = self.img.layersStack[layer.getLowerVisibleStackIndex()]
lower = self.img.layersStack[layerStackIndex -
1] # case index == 0 doesn't matter
# toggle actions
self.cMenu.actionMergingFlag.setChecked(layer.mergingFlag)
self.cMenu.actionMerge.setEnabled(not (
hasattr(layer, 'inputImg') or hasattr(lowerVisible, 'inputImg')))
self.actionDup.setEnabled(not layer.isAdjustLayer())
self.cMenu.actionColorMaskEnable.setChecked(layer.maskIsSelected
and layer.maskIsEnabled)
self.cMenu.actionOpacityMaskEnable.setChecked(
(not layer.maskIsSelected) and layer.maskIsEnabled)
self.cMenu.actionClippingMaskEnable.setChecked(
layer.isClipping and (layer.maskIsSelected or layer.maskIsEnabled))
self.cMenu.actionMaskDisable.setChecked(not (
layer.isClipping or layer.maskIsSelected or layer.maskIsEnabled))
self.cMenu.actionMaskUndo.setEnabled(layer.historyListMask.canUndo())
self.cMenu.actionMaskRedo.setEnabled(layer.historyListMask.canRedo())
self.cMenu.subMenuEnable.setEnabled(len(rows) == 1)
self.cMenu.actionMaskPaste.setEnabled(
not QApplication.clipboard().image().isNull())
self.cMenu.actionImagePaste.setEnabled(
not QApplication.clipboard().image().isNull())
# Event handlers
def RepositionLayer():
layer.xOffset, layer.yOffset = 0, 0
layer.Zoom_coeff = 1.0
layer.AltZoom_coeff = 1.0
layer.xAltOffset, layer.yAltOffset = 0, 0
layer.updatePixmap()
self.img.onImageChanged()
def merge():
layer.merge_with_layer_immediately_below()
def testUpperVisibility():
pos = self.img.getStackIndex(layer)
upperVisible = False
for i in range(len(self.img.layersStack) - pos - 1):
if self.img.layersStack[pos + 1 + i].visible:
upperVisible = True
break
if upperVisible:
dlgWarn("Upper visible layers slow down mask edition")
return True
return False
def colorMaskEnable():
testUpperVisibility()
layer.maskIsEnabled = True
layer.maskIsSelected = True
self.maskLabel.setEnabled(layer.maskIsSelected)
self.maskSlider.setEnabled(layer.maskIsSelected)
self.maskValue.setEnabled(layer.maskIsSelected)
layer.applyToStack()
self.img.onImageChanged()
def opacityMaskEnable():
testUpperVisibility()
layer.maskIsEnabled = True
layer.maskIsSelected = False
self.maskLabel.setEnabled(layer.maskIsSelected)
self.maskSlider.setEnabled(layer.maskIsSelected)
self.maskValue.setEnabled(layer.maskIsSelected)
layer.applyToStack()
self.img.onImageChanged()
def clippingMaskEnable():
layer.maskIsEnabled = True
layer.maskIsSelected = False
self.maskLabel.setEnabled(layer.maskIsSelected)
self.maskSlider.setEnabled(layer.maskIsSelected)
self.maskValue.setEnabled(layer.maskIsSelected)
layer.isClipping = True
layer.applyToStack()
self.img.onImageChanged()
def maskDisable():
layer.maskIsEnabled = False
layer.maskIsSelected = False
self.maskLabel.setEnabled(layer.maskIsSelected)
self.maskSlider.setEnabled(layer.maskIsSelected)
self.maskValue.setEnabled(layer.maskIsSelected)
layer.isClipping = False
layer.applyToStack()
self.img.onImageChanged()
def undoMask():
mask = layer.historyListMask.undo(saveitem=layer.mask.copy())
if mask is not None:
layer.mask = mask
layer.applyToStack()
self.img.onImageChanged()
def redoMask():
mask = layer.historyListMask.redo()
if mask is not None:
layer.mask = mask
layer.applyToStack()
self.img.onImageChanged()
def maskInvert():
layer.invertMask()
# update mask stack
layer.applyToStack()
self.img.onImageChanged()
def maskReset_UM():
layer.resetMask(maskAll=False)
# update mask stack
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.execute(l=None, pool=None)
self.img.onImageChanged()
def maskReset_M():
layer.resetMask(maskAll=True)
# update mask stack
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.execute(l=None, pool=None)
self.img.onImageChanged()
def maskCopy():
QApplication.clipboard().setImage(layer.mask)
def imageCopy():
QApplication.clipboard().setImage(layer.getCurrentMaskedImage())
def maskPaste():
"""
Pastes clipboard to mask and updates the stack. The clipboard image
is scaled if its size does not match the size of the mask
"""
cb = QApplication.clipboard()
if not cb.image().isNull():
img = cb.image()
if img.size() == layer.mask.size():
layer.mask = img
else:
layer.mask = img.scaled(layer.mask.size())
layer.applyToStack()
self.img.prLayer.execute(l=None, pool=None)
self.img.onImageChanged()
def imagePaste():
"""
Pastes clipboard to mask and updates the stack. The clipboard image
is scaled if its size does not match the size of the mask
"""
cb = QApplication.clipboard()
if not cb.image().isNull():
srcImg = cb.image()
if srcImg.size() == layer.size():
layer.setImage(srcImg)
else:
layer.setImage(srcImg.scaled(layer.size()))
layer.applyToStack()
self.img.onImageChanged()
def maskDilate():
"""
Increase the masked part of the image
"""
buf = QImageBuffer(layer.mask)
buf[:, :, 2] = vImage.maskDilate(buf[:, :, 2])
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskErode():
"""
Reduce the masked part of the image
"""
buf = QImageBuffer(layer.mask)
buf[:, :, 2] = vImage.maskErode(buf[:, :, 2])
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskSmooth():
"""
Smooth the mask boundary
"""
buf = QImageBuffer(layer.mask)
buf[:, :, 2] = vImage.maskSmooth(buf[:, :, 2])
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskBright1():
layer.setMaskLuminosity(min=128, max=255)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskBright2():
layer.setMaskLuminosity(min=192, max=255)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskBright3():
layer.setMaskLuminosity(min=224, max=255)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskDark1():
layer.setMaskLuminosity(min=0, max=128)
def maskDark2():
layer.setMaskLuminosity(min=0, max=64)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskDark3():
layer.setMaskLuminosity(min=0, max=32)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskMid1():
layer.setMaskLuminosity(min=64, max=192)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskMid2():
layer.setMaskLuminosity(min=96, max=160)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def maskMid3():
layer.setMaskLuminosity(min=112, max=144)
for l in self.img.layersStack:
l.updatePixmap(maskOnly=True)
self.img.prLayer.update()
self.img.onImageChanged()
def mergingFlag(flag):
layer.mergingFlag = flag
self.cMenu.actionRepositionLayer.triggered.connect(RepositionLayer)
# self.cMenu.actionLoadImage.triggered.connect(loadImage)
self.cMenu.actionMerge.triggered.connect(merge)
self.cMenu.actionColorMaskEnable.triggered.connect(colorMaskEnable)
self.cMenu.actionOpacityMaskEnable.triggered.connect(opacityMaskEnable)
self.cMenu.actionClippingMaskEnable.triggered.connect(
clippingMaskEnable)
self.cMenu.actionMaskDisable.triggered.connect(maskDisable)
self.cMenu.actionMaskUndo.triggered.connect(undoMask)
self.cMenu.actionMaskRedo.triggered.connect(redoMask)
self.cMenu.actionMaskInvert.triggered.connect(maskInvert)
self.cMenu.actionMaskReset_UM.triggered.connect(maskReset_UM)
self.cMenu.actionMaskReset_M.triggered.connect(maskReset_M)
self.cMenu.actionMaskCopy.triggered.connect(maskCopy)
self.cMenu.actionMaskPaste.triggered.connect(maskPaste)
self.cMenu.actionImageCopy.triggered.connect(imageCopy)
self.cMenu.actionImagePaste.triggered.connect(imagePaste)
self.cMenu.actionMaskDilate.triggered.connect(maskDilate)
self.cMenu.actionMaskErode.triggered.connect(maskErode)
self.cMenu.actionMaskSmooth.triggered.connect(maskSmooth)
self.cMenu.actionMaskBright1.triggered.connect(maskBright1)
self.cMenu.actionMaskBright2.triggered.connect(maskBright2)
self.cMenu.actionMaskBright3.triggered.connect(maskBright3)
self.cMenu.actionMaskDark1.triggered.connect(maskDark1)
self.cMenu.actionMaskDark2.triggered.connect(maskDark2)
self.cMenu.actionMaskDark3.triggered.connect(maskDark3)
self.cMenu.actionMaskMid1.triggered.connect(maskMid1)
self.cMenu.actionMaskMid2.triggered.connect(maskMid2)
self.cMenu.actionMaskMid3.triggered.connect(maskMid3)
self.cMenu.actionMergingFlag.toggled.connect(mergingFlag)
self.cMenu.exec_(event.globalPos() - QPoint(400, 0))
# update table
for row in rows:
self.updateRow(row)
def testDrawOverloads(self):
'''Calls QPainter.drawLines overloads, if something is
wrong Exception and chaos ensues. Bug #395'''
self.painter.drawLines([QLine(QPoint(0,0), QPoint(1,1))])
self.painter.drawLines([QPoint(0,0), QPoint(1,1)])
self.painter.drawLines([QPointF(0,0), QPointF(1,1)])
self.painter.drawLines([QLineF(QPointF(0,0), QPointF(1,1))])
self.painter.drawPoints([QPoint(0,0), QPoint(1,1)])
self.painter.drawPoints([QPointF(0,0), QPointF(1,1)])
self.painter.drawConvexPolygon([QPointF(10.0, 80.0),
QPointF(20.0, 10.0),
QPointF(80.0, 30.0),
QPointF(90.0, 70.0)])
self.painter.drawConvexPolygon([QPoint(10.0, 80.0),
QPoint(20.0, 10.0),
QPoint(80.0, 30.0),
QPoint(90.0, 70.0)])
self.painter.drawPolygon([QPointF(10.0, 80.0),
QPointF(20.0, 10.0),
QPointF(80.0, 30.0),
QPointF(90.0, 70.0)])
self.painter.drawPolygon([QPoint(10.0, 80.0),
QPoint(20.0, 10.0),
QPoint(80.0, 30.0),
QPoint(90.0, 70.0)])
self.painter.drawPolyline([QPointF(10.0, 80.0),
QPointF(20.0, 10.0),
QPointF(80.0, 30.0),
QPointF(90.0, 70.0)])
self.painter.drawPolyline([QPoint(10.0, 80.0),
QPoint(20.0, 10.0),
QPoint(80.0, 30.0),
QPoint(90.0, 70.0)])
def draw_mini_map(self, painter, is_full=False):
_pixmap_minimap = QPixmap(
QSize(min([self.width(), self.height()]),
min([self.width(), self.height()]))) if is_full else QPixmap(
QSize(350, 350))
if is_full:
_p_origin = QPoint((self.width() - _pixmap_minimap.width()) // 2,
(self.height() - _pixmap_minimap.height()) // 2)
else:
_p_origin = QPoint(self.width() - _pixmap_minimap.width(),
self.height() - _pixmap_minimap.height())
_pixmap_minimap.fill(QColor('#00284d'))
# DRAW DEAD ZONE
_dz_radius = self.controller.get_dead_zone_radius()
_xy = QPoint(*self.controller.get_dead_zone_center().tolist())
# GET MOBILE OBJECTS
_model_ships = self.controller.get_data_from_players(enemy_only=False)
_model_bolts = self.controller.get_data_from_bolts()
_model_asteroids = self.controller.get_data_from_asteroids()
# SET MINI MAP
_w_ratio = _pixmap_minimap.width() / (PartyConst.WIDTH * 1.25)
_h_ratio = _pixmap_minimap.height() / (PartyConst.HEIGHT * 1.25)
_minimap_painter = QPainter(_pixmap_minimap)
_minimap_painter.setOpacity(1)
for _ship in _model_ships:
_w = _ship.radius * _w_ratio
if _w < 3:
_w = 3
_x, _y = int(
_ship.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_ship.y * _h_ratio) + _pixmap_minimap.height() // 2
if _ship.is_alive:
_factor_1 = (time.time() * 2) % 2
_factor_2 = (time.time() * 2 + .5) % 2
_minimap_painter.setPen(
QPen(QColor('#ffffff'), 1, Qt.SolidLine))
_minimap_painter.setOpacity(1 - _factor_1)
_minimap_painter.drawEllipse(QPoint(_x, _y),
int(20 * _factor_1),
int(20 * _factor_1))
_minimap_painter.setOpacity(1 - _factor_2)
_minimap_painter.drawEllipse(QPoint(_x, _y),
int(20 * _factor_2),
int(20 * _factor_2))
_minimap_painter.setPen(
QPen(QColor(*_ship.color), _w, Qt.SolidLine))
_minimap_painter.setOpacity(1)
_minimap_painter.drawPoint(_x, _y)
for _astroid in _model_asteroids:
_w = _astroid.radius * _w_ratio
if _w < 5:
_w = 5
_pen = QPen(QColor('#ffb86c'), _w, Qt.SolidLine)
_pen.setCapStyle(Qt.RoundCap)
_minimap_painter.setPen(_pen)
_x, _y = int(
_astroid.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_astroid.y * _h_ratio) + _pixmap_minimap.height() // 2
_minimap_painter.drawPoint(_x, _y)
for _bolt in _model_bolts:
_w = _bolt.radius * _w_ratio
if _w < 1:
_w = 1
_minimap_painter.setPen(QPen(QColor('#ff5555'), _w, Qt.SolidLine))
_x, _y = int(
_bolt.x * _w_ratio) + _pixmap_minimap.width() // 2, int(
_bolt.y * _h_ratio) + _pixmap_minimap.height() // 2
_minimap_painter.drawPoint(_x, _y)
_xy.setX(_xy.x() * _w_ratio + _pixmap_minimap.width() // 2)
_xy.setY(_xy.y() * _h_ratio + _pixmap_minimap.height() // 2)
_minimap_painter.setPen(QPen(QColor('#8be9fd'), 3, Qt.SolidLine))
_minimap_painter.drawEllipse(_xy, _dz_radius * _w_ratio,
_dz_radius * _h_ratio)
if not is_full:
_minimap_painter.setPen(QPen(QColor('#ffffff'), 1, Qt.SolidLine))
_x = -self.camera_pst.x() * _w_ratio + _pixmap_minimap.width() // 2
_y = self.camera_pst.y() * _h_ratio + _pixmap_minimap.height() // 2
_w = self.width() * _w_ratio
_h = self.height() * _h_ratio
_minimap_painter.drawRect(_x, _y - _h, _w, _h)
_minimap_painter.end()
_pixmap_minimap = _pixmap_minimap.transformed(QTransform().scale(
1, -1))
painter.setOpacity(1 if is_full else .75)
painter.drawPixmap(_p_origin, _pixmap_minimap)
def run(self):
import face_recognition
#detector = dlib.get_frontal_face_detector()
known_faces = {}
persons = [o for o in os.listdir(FACES_DIR)
if os.path.isdir(os.path.join(FACES_DIR,o))]
for person in persons:
images = os.listdir(os.path.join(FACES_DIR, person))
known_faces[person] = list()
for image in images:
if not image.endswith(".jpg"):
continue
image_path = os.path.join(FACES_DIR, person, image)
cache_path = image_path + '.c'
#print("IMAGE for", person, ": ", image)
if os.path.isfile(cache_path):
face_encodings = pickle.load(open(cache_path, "rb"))
else:
image = face_recognition.load_image_file(image_path)
face_encodings = face_recognition.face_encodings(image)
pickle.dump(face_encodings, open(cache_path, "wb"))
#print("FACES", face_encodings)
known_faces[person].append(face_encodings[0])
while not self.exit_event.is_set():
y, u, v, h, w, h2, w2 = self.task_queue.get()
y = y.reshape((h, w))
u = u.reshape((h2, w2)).repeat(2, axis=0).repeat(2, axis=1)
v = v.reshape((h2, w2)).repeat(2, axis=0).repeat(2, axis=1)
yuv_img = np.dstack((y, u, v))[:h, :w, :].astype(np.float)
rgb_img = convertYUVtoRGB(yuv_img)
#print("has detector...")
#dets = detector(rgb_img, 1)
face_locations = face_recognition.face_locations(rgb_img, number_of_times_to_upsample=1, model="hog")
face_encodings = face_recognition.face_encodings(rgb_img, face_locations)
#print("has detected...")
#print("dets", face_locations)
rects = []
for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
#print("Left: {} Top: {} Right: {} Bottom: {}".format(
# left, top, right, bottom))
min_value = 1
min_person = "Unknown"
for person, pictures in known_faces.items():
distances = face_recognition.face_distance(pictures, face_encoding)
#print("FACE distance for ", person, distances)
if min(distances) < min_value and min(distances) < 0.6:
min_value = any(distances)
min_person = person
rects.append([QRect(QPoint(left, top), QPoint(right, bottom)), min_person])
self.task_queue.task_done()
self.result_queue.put(rects)
def keyPressEvent(self, event):
if not self.zoomed:
if event.key() == Qt.Key_Left:
self._normalMap.pan(QPoint(20, 0))
if event.key() == Qt.Key_Right:
self._normalMap.pan(QPoint(-20, 0))
if event.key() == Qt.Key_Up:
self._normalMap.pan(QPoint(0, 20))
if event.key() == Qt.Key_Down:
self._normalMap.pan(QPoint(0, -20))
if event.key() == Qt.Key_Z or event.key() == Qt.Key_Select:
self.dragPos = QPoint(self.width() / 2, self.height() / 2)
self.activateZoom()
else:
if event.key() == Qt.Key_Z or event.key() == Qt.Key_Select:
self.zoomed = False
self.update()
delta = QPoint(0, 0)
if event.key() == Qt.Key_Left:
delta = QPoint(-15, 0)
if event.key() == Qt.Key_Right:
delta = QPoint(15, 0)
if event.key() == Qt.Key_Up:
delta = QPoint(0, -15)
if event.key() == Qt.Key_Down:
delta = QPoint(0, 15)
if delta != QPoint(0, 0):
self.dragPos += delta
self.update()
def paintEvent(self, event):
painter = QPainter(self)
# Draw background
painter.save()
self.brush.setColor(ThemeManager.BG_L2_QC)
self.brush.setStyle(Qt.SolidPattern)
painter.setBrush(self.brush)
painter.setPen(Qt.NoPen)
painter.drawRect(0, 0,
self.size().width() - 1,
self.size().height() - 1)
painter.restore()
# If image is set
if self.imageData:
if self.imageData.isValid():
# Find xy offsets
self.dx = self.size().width() - self.scaledImage.size().width(
) if self.size().width() - self.scaledImage.size().width(
) else self.scaledImage.size().width() - self.size().width()
self.dy = self.size().height() - self.scaledImage.size(
).height() if self.size().height() - self.scaledImage.size(
).height() else self.scaledImage.size().height() - self.size(
).height()
# Paint rescaled image
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.drawPixmap(self.dx / 2, self.dy / 2, self.scaledImage)
# Paint in-progress box
if self.drawingRect:
painter.save()
x, x2, y, y2 = self.drawingRect
# Convert % to xy coords, account for off by one error
x = (x * self.scaledImage.size().width() + self.dx / 2) - 1
y = (y * self.scaledImage.size().height() +
self.dy / 2) - 1
x2 = (x2 * self.scaledImage.size().width() +
self.dx / 2) - 2
y2 = (y2 * self.scaledImage.size().height() +
self.dy / 2) - 2
# Setup painter's brush and pen colors
self.brush.setColor(ThemeManager.ACCENT_VLOW_OPACITY_QC)
self.brush.setStyle(Qt.SolidPattern)
self.pen.setColor(ThemeManager.ACCENT_QC)
painter.setBrush(self.brush)
painter.setPen(self.pen)
painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2)))
painter.restore()
# Paint existing boxes
for box in self.boxes:
painter.save()
x, x2, y, y2 = box.getRect()
# Convert % to xy coords, account for off by one error, and draw box's rect
x = (x * self.scaledImage.size().width() + self.dx / 2) - 1
y = (y * self.scaledImage.size().height() +
self.dy / 2) - 1
x2 = (x2 * self.scaledImage.size().width() +
self.dx / 2) - 1
y2 = (y2 * self.scaledImage.size().height() +
self.dy / 2) - 2
painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2)))
# Setup painter's brush and pen colors
self.brush.setColor(ThemeManager.ACCENT_LOW_OPACITY_QC)
self.brush.setStyle(Qt.SolidPattern)
self.pen.setColor(ThemeManager.ACCENT_QC)
painter.setBrush(self.brush)
painter.setPen(self.pen)
painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2)))
# Draw box's label
pen = QPen()
font = QFont('Arial', 8)
pen.setColor(ThemeManager.LABEL_QC)
painter.setPen(pen)
painter.drawText(x + 2, y + 11, box.getLabel())
painter.restore()
# TODO: Move this logic out of Paint Event
# Image this index was referencing was deleted
else:
self.boxes = []
self.imageData = None
if self.message:
painter.save()
font = QFont('Arial', 20)
messageWidth = QFontMetrics(font).width(self.message)
painter.setFont(font)
self.pen.setColor(ThemeManager.ACCENT_QC)
painter.setPen(self.pen)
painter.drawText((self.width() - messageWidth) / 2,
self.height() * .9, self.message)
painter.restore()
painter.end()
def __init__(self):
super().__init__()
self.setAttribute(
Qt.WA_DeleteOnClose
) # let Qt delete stuff before the python garbage-collector gets to work
self.repo = None
self.branches_model = None
# instantiate main window
self.ui = ui.Ui_MainWindow()
self.ui.setupUi(self)
self.fs_watch = QFileSystemWatcher(self)
self.fs_watch.fileChanged.connect(self.on_file_changed)
self.fs_watch.directoryChanged.connect(self.on_dir_changed)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
'pqgit', 'config')
# for comparison
self.new_c_id, self.old_c_id = None, None
# window icon
cwd = os.path.dirname(os.path.realpath(__file__))
self.setWindowIcon(QIcon(os.path.join(cwd, 'Git-Icon-White.png')))
self.setWindowTitle('pqgit')
# size and position
self.move(self.settings.value('w/pos', QPoint(200, 200)))
self.resize(self.settings.value('w/size', QSize(1000, 1000)))
self.ui.hist_splitter.setSizes([
int(s) for s in self.settings.value('w/hist_splitter', [720, 360])
])
self.ui.cinf_splitter.setSizes([
int(s) for s in self.settings.value('w/cinf_splitter', [360, 360])
])
self.ui.diff_splitter.setSizes([
int(s)
for s in self.settings.value('w/diff_splitter', [150, 1200, 230])
])
# open repo dir
open_shortcut = QShortcut(QKeySequence('Ctrl+O'), self)
open_shortcut.activated.connect(self.open_dir)
# set-up ui
self.branches_model = BranchesModel()
self.ui.tvBranches.setModel(self.branches_model)
self.ui.tvBranches.selectionModel().selectionChanged.connect(
self.branches_selection_changed)
self.ui.tvBranches.resizeColumnsToContents()
self.history_model = HistoryModel()
self.ui.tvHistory.setModel(self.history_model)
self.ui.tvHistory.selectionModel().selectionChanged.connect(
self.history_selection_changed)
self.files_model = FilesModel()
self.ui.tvFiles.setModel(self.files_model)
self.ui.tvFiles.selectionModel().selectionChanged.connect(
self.files_selection_changed)
self.ui.tvFiles.doubleClicked.connect(self.on_file_doubleclicked)
for view in (self.ui.tvBranches, self.ui.tvHistory, self.ui.tvFiles):
view.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
view.setSelectionBehavior(QAbstractItemView.SelectRows)
view.setShowGrid(False)
view.verticalHeader().setDefaultSectionSize(
QApplication.font().pointSize() + 2)
view.verticalHeader().hide()
self.ui.teDiff.setFont(QFont('Monospace'))
self.difftools = []
timer = QTimer(self)
timer.timeout.connect(self.on_timer)
timer.start(5000)
self.dir_name = self.settings.value('last_opened_repo', None)
try:
pygit2.Repository(self.dir_name)
except Exception: #pylint: disable=broad-except
self.open_dir()
return
self.open_repo()
def resizeEvent(self, resizeEvent: QResizeEvent):
self.paintStep = min(self.width() / self.size, self.height() / self.size)
self.paintOffset = QPoint((self.paintStep + (self.width() - self.paintStep * self.size)) / 2,
(self.paintStep + (self.height() - self.paintStep * self.size)) / 2)
self.player = self.playerNode.point
def mouseMoveEvent(self, event):
if self.mouseIsDown:
self.center = QPoint(event.pos().x(), event.pos().y())
self.viewport().repaint()
QTableView.mouseMoveEvent(self, event)
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
super().__init__(targetImage=targetImage, axeSize=axeSize, layer=layer, parent=parent)
graphicsScene = self.scene()
#########
# L curve
#########
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicR = cubic
cubic.channel = channelValues.L
# get histogram as a Qimage
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(0, 1),
chans=channelValues.L, mode='Lab')
# L curve use the default axes
cubic.axes = graphicsScene.defaultAxes
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
##########
# a curve (Green--> Magenta axis)
#########
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicG = cubic
cubic.channel = channelValues.a
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(-100, 100),
chans=channelValues.a, mode='Lab')
# add specific axes
gradient = QRadialGradient()
gradient.setCenter(QPoint(0, 1))
gradient.setRadius(axeSize*1.4)
gradient.setColorAt(0.0, Qt.green)
gradient.setColorAt(1.0, Qt.magenta)
cubic.axes = self.drawPlotGrid(axeSize, gradient)
graphicsScene.addItem(cubic.axes)
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
# b curve (Blue-->Yellow axis)
cubic = activeCubicSpline(axeSize)
graphicsScene.addItem(cubic)
graphicsScene.cubicB = cubic
cubic.channel = channelValues.b
cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize,
bgColor=graphicsScene.bgColor, range=(-100, 100),
chans=channelValues.b, mode='Lab')
# add specific axes
gradient.setColorAt(0.0, Qt.blue)
gradient.setColorAt(1.0, Qt.yellow)
cubic.axes = self.drawPlotGrid(axeSize, gradient)
graphicsScene.addItem(cubic.axes)
cubic.initFixedPoints()
cubic.axes.setVisible(False)
cubic.setVisible(False)
# set current to L curve and axes
graphicsScene.cubicItem = graphicsScene.cubicR
graphicsScene.cubicItem.setVisible(True)
graphicsScene.cubicItem.axes.setVisible(True)
# buttons
pushButton1 = QPushButton("Reset Current")
pushButton1.adjustSize()
pushButton1.clicked.connect(self.resetCurve)
pushButton2 = QPushButton("Reset All")
pushButton2.adjustSize()
pushButton2.clicked.connect(self.resetAllCurves)
# options
options = ['L', 'a', 'b']
self.listWidget1 = optionsWidget(options=options, exclusive=True)
self.listWidget1.setMinimumSize(self.listWidget1.sizeHintForColumn(0) + 5,
self.listWidget1.sizeHintForRow(0) * len(options) + 5)
# selection changed handler
curves = [graphicsScene.cubicR, graphicsScene.cubicG, graphicsScene.cubicB]
curveDict = dict(zip(options, curves))
def onSelect1(item):
cubicItem = self.scene().cubicItem
cubicItem.setVisible(False)
cubicItem.axes.setVisible(False)
self.scene().cubicItem = curveDict[item.text()]
self.scene().cubicItem.setVisible(True)
self.scene().cubicItem.axes.setVisible(True)
# Force to redraw histogram
self.scene().invalidate(QRectF(0.0, -self.scene().axeSize, self.scene().axeSize, self.scene().axeSize),
QGraphicsScene.BackgroundLayer)
self.listWidget1.onSelect = onSelect1
# set initial selection to L
item = self.listWidget1.items[options[0]]
item.setCheckState(Qt.Checked)
self.listWidget1.select(item)
self.setWhatsThis("""<b>Lab curves</b><br>""" + self.whatsThis())
def f():
l = graphicsScene.layer
l.applyToStack()
l.parentImage.onImageChanged()
self.scene().cubicR.curveChanged.sig.connect(f)
self.scene().cubicG.curveChanged.sig.connect(f)
self.scene().cubicB.curveChanged.sig.connect(f)
# layout
gl = QGridLayout()
gl.addWidget(self.listWidget1, 0, 0, 2, 1)
for i, button in enumerate([pushButton1, pushButton2]):
gl.addWidget(button, i, 1)
self.addCommandLayout(gl)
def __init__(
self,
campaigns: List[Campaign],
faction_selection: FactionSelection,
parent=None,
) -> None:
super().__init__(parent)
self.faction_selection = faction_selection
self.setTitle("Theater configuration")
self.setSubTitle("\nChoose a terrain and time period for this game.")
self.setPixmap(
QtWidgets.QWizard.LogoPixmap,
QtGui.QPixmap("./resources/ui/wizard/logo1.png"),
)
self.setPixmap(
QtWidgets.QWizard.WatermarkPixmap,
QtGui.QPixmap("./resources/ui/wizard/watermark3.png"),
)
# List of campaigns
campaignList = QCampaignList(campaigns)
self.registerField("selectedCampaign", campaignList)
# Faction description
self.campaignMapDescription = QTextEdit("")
self.campaignMapDescription.setReadOnly(True)
self.campaignMapDescription.setMaximumHeight(100)
self.performanceText = QTextEdit("")
self.performanceText.setReadOnly(True)
self.performanceText.setMaximumHeight(90)
# Campaign settings
mapSettingsGroup = QtWidgets.QGroupBox("Map Settings")
invertMap = QtWidgets.QCheckBox()
self.registerField("invertMap", invertMap)
mapSettingsLayout = QtWidgets.QGridLayout()
mapSettingsLayout.addWidget(QtWidgets.QLabel("Invert Map"), 0, 0)
mapSettingsLayout.addWidget(invertMap, 0, 1)
mapSettingsGroup.setLayout(mapSettingsLayout)
# Time Period
timeGroup = QtWidgets.QGroupBox("Time Period")
timePeriod = QtWidgets.QLabel("Start date :")
timePeriodSelect = QtWidgets.QComboBox()
timePeriodPresetLabel = QLabel("Use preset :")
timePeriodPreset = QtWidgets.QCheckBox()
timePeriodPreset.setChecked(True)
self.calendar = QLiberationCalendar()
self.calendar.setSelectedDate(QDate())
self.calendar.setDisabled(True)
def onTimePeriodChanged():
self.calendar.setSelectedDate(
list(
db.TIME_PERIODS.values())[timePeriodSelect.currentIndex()])
timePeriodSelect.currentTextChanged.connect(onTimePeriodChanged)
for r in db.TIME_PERIODS:
timePeriodSelect.addItem(r)
timePeriod.setBuddy(timePeriodSelect)
timePeriodSelect.setCurrentIndex(21)
def onTimePeriodCheckboxChanged():
if timePeriodPreset.isChecked():
self.calendar.setDisabled(True)
timePeriodSelect.setDisabled(False)
onTimePeriodChanged()
else:
self.calendar.setDisabled(False)
timePeriodSelect.setDisabled(True)
timePeriodPreset.stateChanged.connect(onTimePeriodCheckboxChanged)
# Bind selection method for campaign selection
def on_campaign_selected():
template = jinja_env.get_template("campaigntemplate_EN.j2")
template_perf = jinja_env.get_template(
"campaign_performance_template_EN.j2")
index = campaignList.selectionModel().currentIndex().row()
campaign = campaignList.campaigns[index]
self.setField("selectedCampaign", campaign)
self.campaignMapDescription.setText(
template.render({"campaign": campaign}))
self.faction_selection.setDefaultFactions(campaign)
self.performanceText.setText(
template_perf.render({"performance": campaign.performance}))
campaignList.selectionModel().setCurrentIndex(
campaignList.indexAt(QPoint(1, 1)), QItemSelectionModel.Rows)
campaignList.selectionModel().selectionChanged.connect(
on_campaign_selected)
on_campaign_selected()
# Docs Link
docsText = QtWidgets.QLabel(
'<a href="https://github.com/Khopa/dcs_liberation/wiki/Custom-Campaigns"><span style="color:#FFFFFF;">How to create your own theater</span></a>'
)
docsText.setAlignment(Qt.AlignCenter)
docsText.setOpenExternalLinks(True)
# Register fields
self.registerField("timePeriod", timePeriodSelect)
self.registerField("usePreset", timePeriodPreset)
timeGroupLayout = QtWidgets.QGridLayout()
timeGroupLayout.addWidget(timePeriodPresetLabel, 0, 0)
timeGroupLayout.addWidget(timePeriodPreset, 0, 1)
timeGroupLayout.addWidget(timePeriod, 1, 0)
timeGroupLayout.addWidget(timePeriodSelect, 1, 1)
timeGroupLayout.addWidget(self.calendar, 0, 2, 3, 1)
timeGroup.setLayout(timeGroupLayout)
layout = QtWidgets.QGridLayout()
layout.setColumnMinimumWidth(0, 20)
layout.addWidget(campaignList, 0, 0, 5, 1)
layout.addWidget(docsText, 5, 0, 1, 1)
layout.addWidget(self.campaignMapDescription, 0, 1, 1, 1)
layout.addWidget(self.performanceText, 1, 1, 1, 1)
layout.addWidget(mapSettingsGroup, 2, 1, 1, 1)
layout.addWidget(timeGroup, 3, 1, 3, 1)
self.setLayout(layout)
def qpointTimesQMatrix(point, matrix):
'''As seen in "QPoint QMatrix::map(const QPoint &p) const" C++ implementation.'''
return QPoint(
matrix.m11() * point.x() + matrix.m21() * point.y() + matrix.dx(),
matrix.m12() * point.x() + matrix.m22() * point.y() + matrix.dy())
def _show_menu(self, index, pos):
node_id, \
node_name, \
is_online, \
is_itself, \
is_wiped = self._model.get_node_id_online_itself(index)
if not node_id:
return
license_free = self._license_type == FREE_LICENSE
menu = QMenu(self._view)
menu.setStyleSheet("background-color: #EFEFF4; ")
menu.setToolTipsVisible(license_free)
if license_free:
menu.setStyleSheet(
'QToolTip {{background-color: #222222; color: white;}}')
menu.hovered.connect(lambda a: self._on_menu_hovered(a, menu))
def add_menu_item(caption,
index=None,
action_name=None,
action_type="",
start_transfers=False,
disabled=False,
tooltip=""):
action = menu.addAction(caption)
action.setEnabled(not disabled)
action.tooltip = tooltip if tooltip else ""
if not start_transfers:
action.triggered.connect(lambda: self._on_menu_clicked(
index, action_name, action_type))
else:
action.triggered.connect(self.start_transfers.emit)
tooltip = tr("Not available for free license") \
if license_free and not is_itself else ""
if not is_online:
action_in_progress = ("hideNode", "") in \
self._nodes_actions.get(node_id, set())
item_text = tr("Remove node") if not action_in_progress \
else tr("Remove node in progress...")
add_menu_item(item_text,
index,
"hideNode",
disabled=action_in_progress)
elif is_itself:
add_menu_item(tr("Transfers..."), start_transfers=True)
if not is_wiped:
wipe_in_progress = ("execute_remote_action", "wipe") in \
self._nodes_actions.get(node_id, set())
if not wipe_in_progress:
action_in_progress = ("execute_remote_action", "logout") in \
self._nodes_actions.get(node_id, set())
item_text = tr("Log out") if not action_in_progress \
else tr("Log out in progress...")
add_menu_item(item_text,
index,
"execute_remote_action",
"logout",
disabled=action_in_progress
or license_free and not is_itself,
tooltip=tooltip)
item_text = tr("Log out && wipe") if not wipe_in_progress \
else tr("Wipe in progress...")
add_menu_item(item_text,
index,
"execute_remote_action",
"wipe",
disabled=wipe_in_progress
or license_free and not is_itself,
tooltip=tooltip)
pos_to_show = QPoint(pos.x(), pos.y() + 20)
menu.exec_(self._view.mapToGlobal(pos_to_show))
def testMatrixWithWrongType(self):
matrix = QMatrix(11, 12, 21, 22, 100, 200)
point = QPoint(3, 3)
self.assertRaises(TypeError, matrix.__mul__, point)
def mousePressEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.lastDragPos = QPoint(event.pos())
def get_lineSeries_psnr(self):
lineSeries = QtCharts.QLineSeries()
for i in range(0, len(self.psnr)):
lineSeries.append(QPoint(i, self.psnr[i]))
lineSeries.setName(self.filename)
return lineSeries
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.pixmapOffset += event.pos() - self.lastDragPos
self.lastDragPos = QPoint(event.pos())
self.update()
def setUp(self):
#Acquire resources
self.x, self.y = 10, 20
self.neg_x, self.neg_y = -self.x, -self.y
self.qpoint = QPoint(self.x, self.y)
def transform_screen_to_world(self, x: int, y: int, is_point=True):
_point = round(x - self.camera_pst.x()), round(y - self.camera_pst.y())
if is_point:
return QPoint(*_point)
return _point