def open_file(self):
"""
Open image file for editing, scaling the smaller dimension and cropping the remainder.
:return:
"""
path, _ = QFileDialog.getOpenFileName(
self, "Open file", "",
"PNG image files (*.png); JPEG image files (*jpg); All files (*.*)"
)
if path:
pixmap = QPixmap()
pixmap.load(path)
# We need to crop down to the size of our canvas. Get the size of the loaded image.
iw = pixmap.width()
ih = pixmap.height()
# Get the size of the space we're filling.
cw, ch = CANVAS_DIMENSIONS
if iw / cw < ih / ch: # The height is relatively bigger than the width.
pixmap = pixmap.scaledToWidth(cw)
hoff = (pixmap.height() - ch) // 2
pixmap = pixmap.copy(
QRect(QPoint(0, hoff), QPoint(cw,
pixmap.height() - hoff)))
elif iw / cw > ih / ch: # The height is relatively bigger than the width.
pixmap = pixmap.scaledToHeight(ch)
woff = (pixmap.width() - cw) // 2
pixmap = pixmap.copy(
QRect(QPoint(woff, 0), QPoint(pixmap.width() - woff, ch)))
self.imagefilePath = path # for the opened sketch files
self.ui.Canvas.setPixmap(pixmap)
def open_file(self):
path, _ = QFileDialog.getOpenFileName(
self, "Open file", "",
"PNG image files (*.png); JPEG image files (*jpg); All files (*.*)"
)
if path:
pixmap = QPixmap()
pixmap.load(path)
iw = pixmap.width()
ih = pixmap.height()
cw, ch = CANVAS_DIMENSIONS
if iw / cw < ih / ch:
pixmap = pixmap.scaledToWidth(cw)
hoff = (pixmap.height() - ch) // 2
pixmap = pixmap.copy(
QRect(QPoint(0, hoff), QPoint(cw,
pixmap.height() - hoff)))
elif iw / cw > ih / ch:
pixmap = pixmap.scaledToHeight(ch)
woff = (pixmap.width() - cw) // 2
pixmap = pixmap.copy(
QRect(QPoint(woff, 0), QPoint(pixmap.width() - woff, ch)))
self.canvas.setPixmap(pixmap)
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
self.origin_pixmap = QPixmap("apple.jpg")
self.init_ui()
def init_ui(self):
self.setMinimumWidth(320)
self.setMinimumHeight(240)
layout = QBoxLayout(QBoxLayout.LeftToRight)
self.setLayout(layout)
lb_1 = Label()
self.origin_pixmap = self.origin_pixmap.scaledToHeight(240) # 사이즈가 조정
lb_1.setPixmap(self.origin_pixmap)
layout.addWidget(lb_1)
# 자를 영역 선택, 복사
rect = QRect(50, 50, 50, 50)
cropped = self.origin_pixmap.copy(rect)
self.lb_2 = QLabel()
self.lb_2.setPixmap(cropped)
self.lb_2.setFixedSize(100, 100)
layout.addWidget(self.lb_2)
lb_1.selection_changed.connect(self.crop_image)
@pyqtSlot(QRect, name="cropImage")
def crop_image(self, crop_rect):
# 자를 영역 선택, 복사
cropped = self.origin_pixmap.copy(crop_rect)
self.lb_2.setPixmap(cropped)
def __init__(self):
#Program icon
self.progIcon = QPixmap("img/icon175x175.png")
#Flags
_img = QPixmap("img/flags.png")
self.flag = [
QPixmap(_img.copy(37 * (i % 10), 22 * (i // 10), 36, 22))
for i in range(80)
]
#buffer the flags - used for showing them in system tooltips
buffer = [QBuffer() for i in range(80)]
for img, buf in zip(self.flag, buffer):
buf.open(QIODevice.WriteOnly)
img.scaledToHeight(12).save(buf, "PNG", quality=100)
self.flagToolTip = [
bytes(i.data().toBase64()).decode() for i in buffer
]
self.emptyFlag = QPixmap(36, 22)
self.emptyFlag.fill(QColor(255, 255, 255, 255))
# Action icons
_img = QPixmap("img/icons.png")
self.icon = [
QIcon(_img.copy(65 * (i % 10), 65 * (i // 10), 64, 64))
for i in range(30)
]
# Advisors
self.advisor = [
QPixmap("img/adv" + str(i + 1) + ".png") for i in range(4)
]
class ProtoObj(object):
def __init__(self, posX=0, posY=0, radX=30, radY=30, parent=None):
super().__init__()
self.posX = posX
self.posY = posY
self.radX = radX
self.radY = radY
self.parent = parent
self.ellipse = QGraphicsEllipseItem(posX, posY, radX, radY)
self.sheet = QPixmap('linkEdit.png')
self.stand = []
self.step = 0
self.state = 0
self.animation_timer = QTimer()
self.animation_timer.timeout.connect(self.animate)
self.animation_timer.setInterval(1000)
self.animation_timer.start()
def initObj(self):
self.ellipse.setPos(self.posX, self.posY)
self.ellipse.setPen(QPen(Qt.transparent, 1))
self.ellipse.setBrush(QBrush(Qt.darkGreen))
self.ellipse.setZValue(0)
self.ellipse.setOpacity(1)
effect = QGraphicsDropShadowEffect(self.parent)
effect.setBlurRadius(15)
effect.setColor(Qt.black)
self.ellipse.setGraphicsEffect(effect)
self.stand.append(self.sheet.copy(10, 15, 100, 120))
self.stand.append(self.sheet.copy(130, 15, 100, 120))
self.stand.append(self.sheet.copy(250, 15, 100, 120))
self.pix = self.parent.m_scene.addPixmap(self.stand[0])
self.pix.setPos(self.posX, self.posY)
self.pix.setOffset(-20, -56)
self.pix.setZValue(2)
self.pix.setScale(1)
def getObj(self):
return [self.ellipse]
def moveObj(self, velX, velY):
self.posX += velX
self.posY += velY
self.pix.setPos(self.posX, self.posY)
def animate(self):
if self.state == 0:
self.step += 1
if self.step > 2:
self.step = 0
'standing'
#self.pix = self.parent.m_scene.addPixmap(self.stand[self.step])
self.pix.setPixmap(self.stand[self.step])
self.pix.setPos(self.posX, self.posY)
#self.pix.setOffset(-20, -70)
self.pix.setZValue(2)
class ScreenInfoManager:
def __init__(self):
self._screenNum = QApplication.desktop().screenCount()
self._screenPos = QApplication.desktop().pos()
self._screenSize = QApplication.desktop().size()
self._captureRegion = QRect()
self._drawRegion = QRect()
self._screenImg = QPixmap()
def refreshScrInfo(self):
self._screenNum = QApplication.desktop().screenCount()
self._screenPos = QApplication.desktop().pos()
self._screenSize = QApplication.desktop().size()
def screenshot(self):
self._screenImg = QPixmap(self._screenSize)
self._screenImg.fill(Qt.black)
painter = QPainter(self._screenImg)
for index, screen in enumerate(QApplication.screens()):
p = screen.grabWindow(0)
offx = QApplication.desktop().pos().x()
offy = QApplication.desktop().pos().y()
x, y, w, h = screen.geometry().getRect()
painter.drawPixmap(QPoint(x - offx, y - offy), p)
def get_captureRegionImg(self) -> QPixmap:
return self._screenImg.copy(self._captureRegion)
def get_drawRegionImg(self) -> QPixmap:
return self._screenImg.copy(self._drawRegion)
@property
def screenImg(self):
return self._screenImg
@property
def captureRegion(self):
return self._captureRegion
@captureRegion.setter
def captureRegion(self, new_captureRegion):
self._captureRegion = new_captureRegion
@property
def drawRegion(self):
return self._drawRegion
@drawRegion.setter
def drawRegion(self, new_drawRegion):
self._drawRegion = new_drawRegion
def drawResultBox(self):
res = QPixmap.copy(self.pixmapOriginal)
painter = QPainter(res)
font = QFont('mono', 30, 1)
painter.setFont(font)
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
i = 0
for box in self.results:
lx, ly, rx, ry = box[:4]
#painter.drawRect(lx, ly, rx-lx, ry-ly)
p1_x = vector_result[i]
p1_y = vector_result[i + 1]
p2_x = vector_result[i + 2]
p2_y = vector_result[i + 3]
new_x1 = vector_result[i + 4]
new_y1 = vector_result[i + 5]
new_x2 = vector_result[i + 6]
new_y2 = vector_result[i + 7]
i = i + 8
painter.drawLine(p1_x, p1_y, new_x1, new_y1)
painter.drawLine(new_x1, new_y1, p2_x, p2_y)
painter.drawLine(p1_x, p1_y, new_x2, new_y2)
painter.drawLine(new_x2, new_y2, p2_x, p2_y)
if len(box) == 5:
painter.setPen(QPen(Qt.blue, 2, Qt.SolidLine))
painter.drawText(lx, ly + 15, self.key_config[box[-1]])
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
return res
def chooseImage(self):
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
None, "Choose Image", "",
"Image Files (*.png *.jpg *.jpeg *.bmp *.gif)")
if filename:
predicted_im = self.predictor.predict(filename)
predicted_im = Image.fromarray(
(predicted_im * 255).astype(np.uint8))
predicted_im = np.array(predicted_im)
original_im = QPixmap(filename)
original_im = original_im.scaled(self.size, self.size,
QtCore.Qt.KeepAspectRatio)
self.originalImage.setPixmap(original_im)
grayscale_im = original_im.copy()
grayscale_im = QtGui.QPixmap.toImage(grayscale_im)
grayscale_im = grayscale_im.convertToFormat(
QImage.Format_Grayscale8)
self.grayscaleImage.setPixmap(
QtGui.QPixmap.fromImage(grayscale_im))
height, width, channel = predicted_im.shape
bytesPerLine = 3 * width
predicted_im = QImage(predicted_im.data, width, height,
bytesPerLine, QImage.Format_RGB888)
self.predictedImage.setPixmap(
QtGui.QPixmap.fromImage(predicted_im))
def mouseMoveEvent(self, event):
self.parent.cursorPos.setText('({}, {})'.format(
event.pos().x(),
event.pos().y()))
if event.buttons() and Qt.LeftButton and self.drawing:
self.pixmap = QPixmap.copy(self.prev_pixmap)
painter = QPainter(self.pixmap)
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
p1_x, p1_y = self.lastPoint.x(), self.lastPoint.y()
p2_x, p2_y = event.pos().x(), event.pos().y()
detx = p2_x - p1_x
dety = p2_y - p1_y
new_x1 = p1_x + (cmath.cos(cmath.pi / 4) * detx +
cmath.sin(cmath.pi / 4) * dety) / cmath.sqrt(2)
new_y1 = p1_y + (cmath.cos(cmath.pi / 4) * dety -
cmath.sin(cmath.pi / 4) * detx) / cmath.sqrt(2)
new_x2 = p1_x + (cmath.cos(-cmath.pi / 4) * detx +
cmath.sin(-cmath.pi / 4) * dety) / cmath.sqrt(2)
new_y2 = p1_y + (-cmath.sin(-cmath.pi / 4) * detx +
cmath.cos(-cmath.pi / 4) * dety) / cmath.sqrt(2)
new_x1, new_y1 = int(new_x1.real), int(new_y1.real)
new_x2, new_y2 = int(new_x2.real), int(new_y2.real)
painter.drawLine(p1_x, p1_y, new_x1, new_y1)
painter.drawLine(new_x1, new_y1, p2_x, p2_y)
painter.drawLine(p1_x, p1_y, new_x2, new_y2)
painter.drawLine(new_x2, new_y2, p2_x, p2_y)
self.update()
def _refresh_scene(self):
self._scene.clear()
self.spriteList.clear()
for k in self._sprites.keys():
sprite = self._sprites[k]
self.spriteList.addItem(k)
if not sprite["is_text"]:
if sprite["render"]["enable"]:
sprite_path = os.path.join(self._currentProject, sprite["path"])
sprite_obj = json.loads(open(sprite_path).read())
image_path = os.path.join(os.path.split(sprite_path)[0], sprite_obj["image"]["path"])
pixmap = QPixmap(image_path)
slice_col = sprite_obj["image"]["col"]
slice_row = sprite_obj["image"]["row"]
slice_width = pixmap.width() // slice_col
slice_height = pixmap.height() // slice_row
slice_index = sprite["render"]["default_frame"]
pixmap = pixmap.copy(
QRect(
(slice_index % slice_col) * slice_width,
(slice_index // slice_col) * slice_height,
slice_width, slice_height))
pixmap = pixmap.scaledToWidth(int(pixmap.width() * sprite["render"]["render_scale"]))
pixmap = QPixmap.fromImage(pixmap.toImage().mirrored(sprite["render"]["flipX"], False))
pixmap_item = self._scene.addPixmap(pixmap)
pixmap_item.setPos(sprite["transform"]["position"]["x"], -sprite["transform"]["position"]["y"])
pixmap_item.moveBy(pixmap.width() // -2, pixmap.height() // -2)
pixmap_item.moveBy(self.sceneView.width() // 2, self.sceneView.height() // 2)
pixmap_item.setZValue(sprite["render"]["layer"])
if sprite["collision"]["enable"]:
pen = QPen(Qt.green, 1, Qt.SolidLine)
c_width = sprite["collision"]["x_size"]
c_height = sprite["collision"]["y_size"]
collision_item = self._scene.addRect(QRectF(
sprite["transform"]["position"]["x"] - c_width // 2,
-sprite["transform"]["position"]["y"] - c_height // 2,
c_width,
c_height
), pen)
collision_item.moveBy(self.sceneView.width() // 2, self.sceneView.height() // 2)
collision_item.setZValue(sprite["render"]["layer"])
else:
if sprite["render"]["enable"]:
text_item = self._scene.addText(
sprite["content"] if len(sprite["content"]) > 0 else k, QFont("Arial", 20))
text_item.setScale(sprite["render"]["render_scale"])
text_item.setPos(sprite["transform"]["position"]["x"], -sprite["transform"]["position"]["y"])
text_item.moveBy(self.sceneView.width() // 2, self.sceneView.height() // 2)
text_item.setZValue(sprite["render"]["layer"])
text_item.setDefaultTextColor(Qt.red)
pen = QPen(Qt.darkGray, 1, Qt.DotLine)
self._scene.addLine(
QLineF(
0, self.sceneView.height() / 2,
self.sceneView.width(), self.sceneView.height() / 2), pen).setZValue(9999)
self._scene.addLine(
QLineF(
self.sceneView.width() / 2, 0,
self.sceneView.width() / 2, self.sceneView.height()), pen).setZValue(9999)
class ThumbLabel(QLabel):
def __init__(
self, widget, canvas, appwindow,
CameraPos): #related to the cavans for recovering the Thumblabel
if widget != None:
super().__init__(
widget) #previous implmentation for adding in centralwidget
else:
super().__init__() #derictly with QLabel for QlistView
self.Canvas = canvas
self.background_color = QColor(Qt.white)
self.bigpixmap = QPixmap(256, 256)
self.bigpixmap.fill(self.background_color) #default white
self.CameraPos = CameraPos
self.AppWindow = appwindow
self.grid = None # try later
self.reset()
def update_grid(self, newgrid):
self.grid = newgrid
def reset(self):
# Create the pixmap for display.
self.setScaledContents(True)
self.setPixmap(QPixmap(36, 36))
self.setMinimumSize(1, 1)
self.setMaximumSize(36, 36) #currently
# Clear the canvas.
self.pixmap().fill(self.background_color)
def setbigmap(self, pixmap):
self.bigpixmap = pixmap.copy() #copy to avoid memory problem
def mouseDoubleClickEvent(self, event):
pixmap = self.bigpixmap.copy() #recover thumbnail to canvas
self.Canvas.setPixmap(pixmap)
self.update_grid(self.AppWindow.getgrid())
#print(self.CameraPos)
#global globalGrid
if self.grid is not None:
rd.update_image(self.CameraPos, self.grid, "opened")
else:
print("Grid is None")
if self.AppWindow is not None:
self.AppWindow.Update_image()
else:
print("AppWindow is None")
def setCanvas(self, canvas):
self.Canvas = canvas
def setCameraPos(self, camerapos):
self.Camerapos = camerapos
def setPaintWindow(self, window):
self.AppWindow = window
def loadFile(self, fileName):
newImage = QPixmap(fileName)
if newImage.isNull():
newImage = QPixmap("thumbnails/black480x360.jpg")
cropRect = QRect(0, 45, 480, 270)
croppedImage = newImage.copy(cropRect)
self.thumbnail.setPixmap(
croppedImage.scaledToWidth(self.thumbnail.width(),
Qt.SmoothTransformation))
def cropToReference(to_be_cropped_pixmap: QtGui.QPixmap,
reference_pixmap: QtGui.QPixmap) -> QtGui.QPixmap:
#help by goetz from https://forum.qt.io/topic/13421/how-to-rotate-a-content-of-qpixmap-without-changing-size/3
reference_width = reference_pixmap.width()
reference_height = reference_pixmap.height()
xoffset = (to_be_cropped_pixmap.width() - reference_width) / 2
yoffset = (to_be_cropped_pixmap.height() - reference_height) / 2
return to_be_cropped_pixmap.copy(xoffset, yoffset, reference_width,
reference_height)
def initUI(self):
self.pixmap = QPixmap('start.png')
self.label_img = QLabel()
self.label_img.setObjectName("image")
self.pixmapOriginal = QPixmap.copy(self.pixmap)
self.drawing = False
self.lastPoint = QPoint()
hbox = QHBoxLayout(self.label_img)
self.setLayout(hbox)
def initialize_sprites(self):
data, script = self.data, self.script_module
sprites = {}
for k in data["sprites"].keys():
sprite = data["sprites"][k]
if sprite["script"]["class_name"] != "":
sprite_instance = Misc.get_sprite(
script, sprite["script"]["class_name"])
else:
sprite_instance = Sprite()
sprite_instance.class_name = sprite["script"]["class_name"]
sprite_instance.input = self.input
sprite_instance.sound = self.sound
sprite_instance.game_application = self
sprite_position = sprite["transform"]["position"]
sprite_instance.transform.position = Vector2(
sprite_position["x"], sprite_position["y"])
sprite_instance.render.enable = sprite["render"]["enable"]
sprite_instance.render.layer = sprite["render"]["layer"]
sprite_instance.render.scale = sprite["render"]["render_scale"]
sprite_instance.is_text = sprite["is_text"]
if not sprite["is_text"]:
sprite_instance.render.flipX = sprite["render"]["flipX"]
sprite_instance.render.default_frame = sprite["render"][
"default_frame"]
sprite_instance.collision.enable = sprite["collision"][
"enable"]
sprite_instance.collision.size.x = sprite["collision"][
"x_size"]
sprite_instance.collision.size.y = sprite["collision"][
"y_size"]
sprite_instance.animator.triggers = sprite["sprite"][
"triggers"]
sprite_instance.animator.animations = sprite["sprite"][
"animations"]
sprite_instance.animator.transitions = sprite["sprite"][
"transitions"]
pixmap = QPixmap()
pixmap.loadFromData(
base64.b64decode(sprite["sprite"]["image"]["data"]))
slice_width = pixmap.width(
) // sprite["sprite"]["image"]["col"]
slice_height = pixmap.height(
) // sprite["sprite"]["image"]["row"]
for y in range(sprite["sprite"]["image"]["row"]):
for x in range(sprite["sprite"]["image"]["col"]):
frame = pixmap.copy(
QRect(x * slice_width, y * slice_height,
slice_width, slice_height))
sprite_instance.animator.frames.append(frame)
else:
sprite_instance.context = sprite["content"]
sprite_instance.script_instance = sprite_instance
sprites[k] = sprite_instance
return sprites
def unpack_sprites(self, filename):
input_pixmap = QPixmap(filename)
frame_count = input_pixmap.width() // self.frame_size.width()
width = self.frame_size.width()
sprites = []
for current_frame in range(1, frame_count+1):
sprites.append(input_pixmap.copy(current_frame * width, 0,
width, self.frame_size.height()))
return sprites
def push(self, pixmap: QPixmap):
# 在中間插入
if self.index < (len(self.data) - 1):
del self.data[self.index + 1:]
new_index = min(self.index + 1, MAX_BUFFER_SIZE)
# 超過上限，從 buffer 移除最舊的一筆
if new_index == self.index:
self.data.pop(0)
self.index = new_index
pm = pixmap.copy()
self.data.append(pm)
def updateAppQRCode(self, target, qrCodePng): qrCodePixmap = QPixmap() qrCodePixmap.loadFromData( qrCodePng, 'png', QtCore.Qt.MonoOnly ) border = 10 #px qrCodePixmap = qrCodePixmap.copy(QtCore.QRect( border, border, qrCodePixmap.width() - border*2, qrCodePixmap.height() - border*2 )) target.setPixmap(qrCodePixmap) target.show()
def mouseMoveEvent(self, event):
self.parent.cursorPos.setText('({}, {})'
.format(event.pos().x(), event.pos().y()))
if event.buttons() and Qt.LeftButton and self.drawing:
self.pixmap = QPixmap.copy(self.prev_pixmap)
painter = QPainter(self.pixmap)
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
p1_x, p1_y = self.lastPoint.x(), self.lastPoint.y()
p2_x, p2_y = event.pos().x(), event.pos().y()
painter.drawRect(min(p1_x, p2_x), min(p1_y, p2_y),
abs(p1_x-p2_x), abs(p1_y-p2_y))
self.update()
def setPixmap(self, pixmap: QPixmap):
# self.imgPixmap = pixmap # 载入图片
# self.scaledImg = self.imgPixmap.copy() # 初始化缩放图
# # self.scaledImg = self.imgPixmap.scaled(self.size()) # 初始化缩放图
# # self.singleOffset = QPoint(0, 0)
# self.repaint()
# self.resize(500, 500) # 设定窗口大小(根据自己显示图片的大小，可更改)
# self.setWindowTitle("图片操作") # 设定窗口名称
self.imgPixmap = pixmap.copy() # 载入图片
# self.scaledImg = self.imgPixmap.scaled(self.size()) # 初始化缩放图
self.scaledImg = pixmap.copy() # 初始化缩放图
self.imageorsize = [(self.width() - pixmap.width()) / 2,
(self.height() - pixmap.height()) / 2]
# print(self.imageorsize)
self.singleOffset = QPoint(self.imageorsize[0],
self.imageorsize[1]) # 初始化偏移值
self.isLeftPressed = bool(False) # 图片被点住(鼠标左键)标志位
self.isImgLabelArea = bool(True) # 鼠标进入label图片显示区域
self.repaint()
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
self.origin_pixmap = QPixmap("apple.jpg")
self.init_ui()
def init_ui(self):
self.setMinimumWidth(320)
self.setMinimumHeight(240)
layout = QBoxLayout(QBoxLayout.LeftToRight)
self.setLayout(layout)
lb_1 = QLabel()
self.origin_pixmap = self.origin_pixmap.scaledToHeight(240) # 사이즈가 조정
lb_1.setPixmap(self.origin_pixmap)
layout.addWidget(lb_1)
# 자를 영역 선택, 복사
rect = QRect(50, 50, 50, 50)
cropped = self.origin_pixmap.copy(rect)
self.lb_2 = QLabel()
self.lb_2.setPixmap(cropped)
self.lb_2.setFixedSize(100, 100)
layout.addWidget(self.lb_2)
w = Rectangle(parent=lb_1)
w.setGeometry(0, 0, 100, 100)
w.setStyleSheet("background-color: red")
opacity_effect = QGraphicsOpacityEffect(self)
opacity_effect.setOpacity(0.3)
w.setGraphicsEffect(opacity_effect)
w.change_position.connect(self.crop_image)
@pyqtSlot(QRect, name="cropImage")
def crop_image(self, crop_rect):
# 자를 영역 선택, 복사
cropped = self.origin_pixmap.copy(crop_rect)
self.lb_2.setPixmap(cropped)
def __init__(self, path, image_width, image_height, image_total, line_count=10):
super().__init__()
image = QPixmap(path)
self.path = path
self.line_count = line_count
self.image_width = image_width
self.image_height = image_height
self._images = []
for i in range(image_total):
x = i % self.line_count
y = i // self.line_count
self._images.append(image.copy(x * self.image_width, y * self.image_height,
self.image_width, self.image_height))
def paintEvent(self, event):
super().paintEvent(event)
if self.switch:
rect =QRect(self.x0, self.y0, abs(self.x1-self.x0), abs(self.y1-self.y0))
painter = QPainter(self)
painter.setPen(QPen(Qt.gray, 1, Qt.SolidLine))
painter.drawRect(rect)
#pqscreen = QGuiApplication.primaryScreen()
#pixmap2 = pqscreen.grabWindow(1, self.x0, self.y0, abs(self.x1-self.x0), abs(self.y1-self.y0))
#pixmap2.save('0000.png')
pixmap = QPixmap.copy(self.pixmap, rect)
pixmap.save('temp/cut.jpg')
self.ok = True
def drawCloudImage(self, painter):
if self.fir.raw():
pixmap = QPixmap()
pixmap.loadFromData(self.fir.raw())
self.imageSize = pixmap.size()
rect = QRect(*self.fir.rect())
image = pixmap.copy(rect)
painter.drawPixmap(0, 0, image)
else:
rect = QRect(0, 0, 260, 260)
painter.setPen(Qt.DashLine)
painter.drawRect(rect)
painter.drawText(rect, Qt.AlignCenter, QCoreApplication.translate('Editor', 'No Satellite Image'))
def selectionDone(self):
"""
This function stop the selection when it's done.
"""
self.qcheckbox_show_filter.setDisabled(False)
image = self.imageArray[self.image_index]
image = QImage(image, image.shape[1], image.shape[0],
QImage.Format_Indexed8)
pix = QPixmap(image)
self.selectedPixmap = pix.copy(self.label_image.rubberBand.geometry())
class Animation(QThread):
trigger = pyqtSignal(QPixmap)
def __init__(self, parent):
super().__init__()
self.contador = 0
self.link = MovilLabel(parent)
self.pixmap = QPixmap("./IMGS/link.png")
# print(self.pixmap.width(), self.pixmap.height())
pixmap = self.pixmap.copy(QRect(0, 910, 120, 1040))
self.link.setPixmap(pixmap)
self.link.setGeometry(0, 500, 120, 130)
self.trigger.connect(parent.animar)
def run(self):
while True:
sleep(0.01)
pixmap = self.pixmap.copy(
QRect(120 * self.contador, 910, 120 * (self.contador + 1),
1040))
self.contador += 1
if self.contador >= 10:
self.contador = 0
self.link.setPixmap(pixmap)
class ChartPatternModel(abstract.AbstractListModel):
def __init__(self, parent=None):
super(ChartPatternModel, self).__init__(parent)
self.patternImage = QPixmap(":/img/patterns.png")
self._foreColor = QColor(Qt.black)
self._backColor = QColor(Qt.white)
self.beginResetModel()
self.setRowSize(48 + 1) # patterns + one solid
self.endResetModel()
def setForeColor(self, color):
self._foreColor = color
def setBackColor(self, color):
self._backColor = color
def foreColor(self):
return self._foreColor
def backColor(self):
return self._backColor
def data(self, index=QModelIndex(), role=Qt.DisplayRole):
if role not in [Qt.DecorationRole, Qt.EditRole]:
return QVariant()
if role == Qt.DecorationRole:
img = None
# solid special case
if index.row() == 0:
img = QPixmap(48, 48)
img.fill(Qt.black)
# pattern case
else:
img = self.patternImage.copy(48 * (index.row() - 1), 0, 48, 48)
foreMask = img.createMaskFromColor(QColor(Qt.white))
backMask = img.createMaskFromColor(QColor(Qt.black))
p = QPainter(img)
p.setPen(self.foreColor())
p.drawPixmap(img.rect(), foreMask, foreMask.rect())
p.setPen(self.backColor())
p.drawPixmap(img.rect(), backMask, backMask.rect())
p.end()
return img
elif role == Qt.EditRole:
if index.row() == 0:
return -2 # solid special case
else:
return index.row()
return QVariant()
def setPixmap(self, image_fn):
self.pixmap = QPixmap(image_fn)
self.W, self.H = self.pixmap.width(), self.pixmap.height()
if self.H > self.screen_height * 0.8:
resize_ratio = (self.screen_height * 0.8) / self.H
self.W = round(self.W * resize_ratio)
self.H = round(self.H * resize_ratio)
self.pixmap = QPixmap.scaled(self.pixmap, self.W, self.H,
transformMode=Qt.SmoothTransformation)
self.parent.imageSize.setText('{}x{}'.format(self.W, self.H))
self.setFixedSize(self.W, self.H)
self.pixmapOriginal = QPixmap.copy(self.pixmap)
def drawResultBox(self):
res = QPixmap.copy(self.pixmapOriginal)
painter = QPainter(res)
font = QFont('mono', 15, 1)
painter.setFont(font)
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
for box in self.results:
lx, ly, rx, ry = box[:4]
painter.drawRect(lx, ly, rx-lx, ry-ly)
if len(box) == 5:
painter.setPen(QPen(Qt.blue, 2, Qt.SolidLine))
painter.drawText(lx, ly+15, self.key_config[box[-1]])
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
return res
class Field:
"""Defines the field of battleships
Have list shot where coordinates are marked as shot
Have list ships where all Ship objects are stored
fieldUI uses field.png pixmap"""
def __init__(self):
"""shot value list:
True - hit
False - miss
number diffrent to -1 - there is a ship in this position"""
self.shot = []
emptyList = [] # Temporary variable for fulfilling the shot list
# Fulfilling shot list as empty
for i in range(0, 10):
emptyList = []
for j in range(0, 10):
emptyList.append(-1)
self.shot.append(emptyList)
del emptyList # We won't need this list anymore
self.ships = []
self.fieldUI = QPixmap("res/pictures/field.png")
def change_field(self, filename, x, y):
"""Method changes graphic on field - adds new image
x, y - coordinates where new graphic should be
filename - path to image"""
new_image = QPixmap(filename)
merge = self.fieldUI.copy()
painter = QPainter(merge)
painter.drawPixmap(x, y, new_image)
painter.end()
self.fieldUI = QPixmap(merge)
def __str__(self):
for i in range(0, 10):
for j in range(0, 10):
print("%5d (%d %d)" % (self.shot[j][i], j, i), " ", end="")
print()
return ""
def get_spell_icon(icon_index):
# Spell Icons are 40x40 pixels
file_number = math.ceil(icon_index / 36)
file_name = "data/spells/spells0" + str(file_number) + ".png"
spell_number = icon_index % 36
file_row = math.floor((spell_number + 6) / 6)
file_col = spell_number % 6 + 1
x = (file_col - 1) * 40
y = (file_row - 1) * 40
icon_image = QPixmap(file_name)
scaled_icon_image = icon_image.copy(QRect(x, y, 40, 40)).scaled(
18, 18, transformMode=Qt.SmoothTransformation)
label = QLabel()
label.setPixmap(scaled_icon_image)
label.setFixedSize(18, 18)
return label
def getPreview(save):
save = BlackAndWhite2SaveGame(save)
lines = [
[
(u"Name : " + save.getName(), Qt.AlignLeft),
(u"| Profile : " + save.getSaveGroupIdentifier()[1:], Qt.AlignLeft),
],
[(u"Land number : " + save.getLand(), Qt.AlignLeft)],
[(u"Saved at : " + save.getCreationTime().toString(), Qt.AlignLeft)],
[(u"Elapsed time : " + save.getElapsed(), Qt.AlignLeft)],
]
pixmap = QPixmap(320, 320)
pixmap.fill()
# rightBuffer = []
painter = QPainter()
painter.begin(pixmap)
fm = painter.fontMetrics()
margin = 5
height = 0
width = 0
ln = 0
for line in lines:
cHeight = 0
cWidth = 0
for (toPrint, align) in line:
bRect = fm.boundingRect(toPrint)
cHeight = bRect.height() * (ln + 1)
bRect.moveTop(cHeight - bRect.height())
if align != Qt.AlignLeft:
continue
else:
bRect.moveLeft(cWidth + margin)
cWidth = cWidth + bRect.width()
painter.drawText(bRect, align, toPrint)
height = max(height, cHeight)
width = max(width, cWidth + (2 * margin))
ln = ln + 1
# height = height + lh
painter.end()
return pixmap.copy(0, 0, width, height)
def setupGame(self, pic):
# reset time and restart timer
self.stop = False
self.time = 0
self.timer = updateTimeThread(self)
self.timer.daemon = True
self.timer.start()
# reset moves and label of moves
self.moves = 0
self.labelMoves.setText(str(self.moves))
# transform the user's picture to a pixmap
pixmap = QPixmap(pic)
# scale the pixmap to fit the 160x160 game widget
pixmap = pixmap.scaled(160, 160,
Qt.KeepAspectRatioByExpanding,
Qt.SmoothTransformation)
# split pixmap and assign splitted pixmaps to tiles
for label in self.labels:
label.setPixmap(pixmap.copy(label.pos().x(),
label.pos().y(),
40,
40))
# top-left tile is empty.
self.labels[0].isEmpty = True
self.labels[0].setPixmap(QPixmap())
# allow moving of tiles
self.setMoveEnabled(True)
# randomize position of tiles by switching them (animations turned off)
for i in range(200):
index = random.choice(range(16))
self.labels[index].switch(False)
class SnapshotRegionGrabber(QWidget):
"""
Class implementing a grabber widget for a rectangular snapshot region.
@signal grabbed(QPixmap) emitted after the region was grabbed
"""
grabbed = pyqtSignal(QPixmap)
StrokeMask = 0
FillMask = 1
Rectangle = 0
Ellipse = 1
def __init__(self, mode=Rectangle):
"""
Constructor
@param mode region grabber mode (SnapshotRegionGrabber.Rectangle or
SnapshotRegionGrabber.Ellipse)
"""
super(SnapshotRegionGrabber, self).__init__(
None,
Qt.X11BypassWindowManagerHint | Qt.WindowStaysOnTopHint |
Qt.FramelessWindowHint | Qt.Tool)
assert mode in [SnapshotRegionGrabber.Rectangle,
SnapshotRegionGrabber.Ellipse]
self.__mode = mode
self.__selection = QRect()
self.__mouseDown = False
self.__newSelection = False
self.__handleSize = 10
self.__mouseOverHandle = None
self.__showHelp = True
self.__grabbing = False
self.__dragStartPoint = QPoint()
self.__selectionBeforeDrag = QRect()
# naming conventions for handles
# T top, B bottom, R Right, L left
# 2 letters: a corner
# 1 letter: the handle on the middle of the corresponding side
self.__TLHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__TRHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__BLHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__BRHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__LHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__THandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__RHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__BHandle = QRect(0, 0, self.__handleSize, self.__handleSize)
self.__handles = [self.__TLHandle, self.__TRHandle, self.__BLHandle,
self.__BRHandle, self.__LHandle, self.__THandle,
self.__RHandle, self.__BHandle]
self.__helpTextRect = QRect()
self.__helpText = self.tr(
"Select a region using the mouse. To take the snapshot, press"
" the Enter key or double click. Press Esc to quit.")
self.__pixmap = QPixmap()
self.setMouseTracking(True)
QTimer.singleShot(200, self.__initialize)
def __initialize(self):
"""
Private slot to initialize the rest of the widget.
"""
self.__desktop = QApplication.desktop()
x = self.__desktop.x()
y = self.__desktop.y()
if qVersion() >= "5.0.0":
self.__pixmap = QApplication.screens()[0].grabWindow(
self.__desktop.winId(), x, y,
self.__desktop.width(), self.__desktop.height())
else:
self.__pixmap = QPixmap.grabWindow(
self.__desktop.winId(), x, y,
self.__desktop.width(), self.__desktop.height())
self.resize(self.__pixmap.size())
self.move(x, y)
self.setCursor(Qt.CrossCursor)
self.show()
self.grabMouse()
self.grabKeyboard()
def paintEvent(self, evt):
"""
Protected method handling paint events.
@param evt paint event (QPaintEvent)
"""
if self.__grabbing: # grabWindow() should just get the background
return
painter = QPainter(self)
pal = QPalette(QToolTip.palette())
font = QToolTip.font()
handleColor = pal.color(QPalette.Active, QPalette.Highlight)
handleColor.setAlpha(160)
overlayColor = QColor(0, 0, 0, 160)
textColor = pal.color(QPalette.Active, QPalette.Text)
textBackgroundColor = pal.color(QPalette.Active, QPalette.Base)
painter.drawPixmap(0, 0, self.__pixmap)
painter.setFont(font)
r = QRect(self.__selection)
if not self.__selection.isNull():
grey = QRegion(self.rect())
if self.__mode == SnapshotRegionGrabber.Ellipse:
reg = QRegion(r, QRegion.Ellipse)
else:
reg = QRegion(r)
grey = grey.subtracted(reg)
painter.setClipRegion(grey)
painter.setPen(Qt.NoPen)
painter.setBrush(overlayColor)
painter.drawRect(self.rect())
painter.setClipRect(self.rect())
drawRect(painter, r, handleColor)
if self.__showHelp:
painter.setPen(textColor)
painter.setBrush(textBackgroundColor)
self.__helpTextRect = painter.boundingRect(
self.rect().adjusted(2, 2, -2, -2),
Qt.TextWordWrap, self.__helpText).translated(
-self.__desktop.x(), -self.__desktop.y())
self.__helpTextRect.adjust(-2, -2, 4, 2)
drawRect(painter, self.__helpTextRect, textColor,
textBackgroundColor)
painter.drawText(
self.__helpTextRect.adjusted(3, 3, -3, -3),
Qt.TextWordWrap, self.__helpText)
if self.__selection.isNull():
return
# The grabbed region is everything which is covered by the drawn
# rectangles (border included). This means that there is no 0px
# selection, since a 0px wide rectangle will always be drawn as a line.
txt = "{0:n}, {1:n} ({2:n} x {3:n})".format(
self.__selection.x(), self.__selection.y(),
self.__selection.width(), self.__selection.height())
textRect = painter.boundingRect(self.rect(), Qt.AlignLeft, txt)
boundingRect = textRect.adjusted(-4, 0, 0, 0)
if textRect.width() < r.width() - 2 * self.__handleSize and \
textRect.height() < r.height() - 2 * self.__handleSize and \
r.width() > 100 and \
r.height() > 100:
# center, unsuitable for small selections
boundingRect.moveCenter(r.center())
textRect.moveCenter(r.center())
elif r.y() - 3 > textRect.height() and \
r.x() + textRect.width() < self.rect().width():
# on top, left aligned
boundingRect.moveBottomLeft(QPoint(r.x(), r.y() - 3))
textRect.moveBottomLeft(QPoint(r.x() + 2, r.y() - 3))
elif r.x() - 3 > textRect.width():
# left, top aligned
boundingRect.moveTopRight(QPoint(r.x() - 3, r.y()))
textRect.moveTopRight(QPoint(r.x() - 5, r.y()))
elif r.bottom() + 3 + textRect.height() < self.rect().bottom() and \
r.right() > textRect.width():
# at bottom, right aligned
boundingRect.moveTopRight(QPoint(r.right(), r.bottom() + 3))
textRect.moveTopRight(QPoint(r.right() - 2, r.bottom() + 3))
elif r.right() + textRect.width() + 3 < self.rect().width():
# right, bottom aligned
boundingRect.moveBottomLeft(QPoint(r.right() + 3, r.bottom()))
textRect.moveBottomLeft(QPoint(r.right() + 5, r.bottom()))
# If the above didn't catch it, you are running on a very
# tiny screen...
drawRect(painter, boundingRect, textColor, textBackgroundColor)
painter.drawText(textRect, Qt.AlignHCenter, txt)
if (r.height() > self.__handleSize * 2 and
r.width() > self.__handleSize * 2) or \
not self.__mouseDown:
self.__updateHandles()
painter.setPen(Qt.NoPen)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.StrokeMask))
painter.drawRect(self.rect())
handleColor.setAlpha(60)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.FillMask))
painter.drawRect(self.rect())
def resizeEvent(self, evt):
"""
Protected method to handle resize events.
@param evt resize event (QResizeEvent)
"""
if self.__selection.isNull():
return
r = QRect(self.__selection)
r.setTopLeft(self.__limitPointToRect(r.topLeft(), self.rect()))
r.setBottomRight(self.__limitPointToRect(r.bottomRight(), self.rect()))
if r.width() <= 1 or r.height() <= 1:
# This just results in ugly drawing...
self.__selection = QRect()
else:
self.__selection = self.__normalizeSelection(r)
def mousePressEvent(self, evt):
"""
Protected method to handle mouse button presses.
@param evt mouse press event (QMouseEvent)
"""
self.__showHelp = not self.__helpTextRect.contains(evt.pos())
if evt.button() == Qt.LeftButton:
self.__mouseDown = True
self.__dragStartPoint = evt.pos()
self.__selectionBeforeDrag = QRect(self.__selection)
if not self.__selection.contains(evt.pos()):
self.__newSelection = True
self.__selection = QRect()
else:
self.setCursor(Qt.ClosedHandCursor)
elif evt.button() == Qt.RightButton:
self.__newSelection = False
self.__selection = QRect()
self.setCursor(Qt.CrossCursor)
self.update()
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse movements.
@param evt mouse move event (QMouseEvent)
"""
shouldShowHelp = not self.__helpTextRect.contains(evt.pos())
if shouldShowHelp != self.__showHelp:
self.__showHelp = shouldShowHelp
self.update()
if self.__mouseDown:
if self.__newSelection:
p = evt.pos()
r = self.rect()
self.__selection = self.__normalizeSelection(
QRect(self.__dragStartPoint,
self.__limitPointToRect(p, r)))
elif self.__mouseOverHandle is None:
# moving the whole selection
r = self.rect().normalized()
s = self.__selectionBeforeDrag.normalized()
p = s.topLeft() + evt.pos() - self.__dragStartPoint
r.setBottomRight(
r.bottomRight() - QPoint(s.width(), s.height()) +
QPoint(1, 1))
if not r.isNull() and r.isValid():
self.__selection.moveTo(self.__limitPointToRect(p, r))
else:
# dragging a handle
r = QRect(self.__selectionBeforeDrag)
offset = evt.pos() - self.__dragStartPoint
if self.__mouseOverHandle in \
[self.__TLHandle, self.__THandle, self.__TRHandle]:
r.setTop(r.top() + offset.y())
if self.__mouseOverHandle in \
[self.__TLHandle, self.__LHandle, self.__BLHandle]:
r.setLeft(r.left() + offset.x())
if self.__mouseOverHandle in \
[self.__BLHandle, self.__BHandle, self.__BRHandle]:
r.setBottom(r.bottom() + offset.y())
if self.__mouseOverHandle in \
[self.__TRHandle, self.__RHandle, self.__BRHandle]:
r.setRight(r.right() + offset.x())
r.setTopLeft(self.__limitPointToRect(r.topLeft(), self.rect()))
r.setBottomRight(
self.__limitPointToRect(r.bottomRight(), self.rect()))
self.__selection = self.__normalizeSelection(r)
self.update()
else:
if self.__selection.isNull():
return
found = False
for r in self.__handles:
if r.contains(evt.pos()):
self.__mouseOverHandle = r
found = True
break
if not found:
self.__mouseOverHandle = None
if self.__selection.contains(evt.pos()):
self.setCursor(Qt.OpenHandCursor)
else:
self.setCursor(Qt.CrossCursor)
else:
if self.__mouseOverHandle in [self.__TLHandle,
self.__BRHandle]:
self.setCursor(Qt.SizeFDiagCursor)
elif self.__mouseOverHandle in [self.__TRHandle,
self.__BLHandle]:
self.setCursor(Qt.SizeBDiagCursor)
elif self.__mouseOverHandle in [self.__LHandle,
self.__RHandle]:
self.setCursor(Qt.SizeHorCursor)
elif self.__mouseOverHandle in [self.__THandle,
self.__BHandle]:
self.setCursor(Qt.SizeVerCursor)
def mouseReleaseEvent(self, evt):
"""
Protected method to handle mouse button releases.
@param evt mouse release event (QMouseEvent)
"""
self.__mouseDown = False
self.__newSelection = False
if self.__mouseOverHandle is None and \
self.__selection.contains(evt.pos()):
self.setCursor(Qt.OpenHandCursor)
self.update()
def mouseDoubleClickEvent(self, evt):
"""
Protected method to handle mouse double clicks.
@param evt mouse double click event (QMouseEvent)
"""
self.__grabRect()
def keyPressEvent(self, evt):
"""
Protected method to handle key presses.
@param evt key press event (QKeyEvent)
"""
if evt.key() == Qt.Key_Escape:
self.grabbed.emit(QPixmap())
elif evt.key() in [Qt.Key_Enter, Qt.Key_Return]:
self.__grabRect()
else:
evt.ignore()
def __updateHandles(self):
"""
Private method to update the handles.
"""
r = QRect(self.__selection)
s2 = self.__handleSize // 2
self.__TLHandle.moveTopLeft(r.topLeft())
self.__TRHandle.moveTopRight(r.topRight())
self.__BLHandle.moveBottomLeft(r.bottomLeft())
self.__BRHandle.moveBottomRight(r.bottomRight())
self.__LHandle.moveTopLeft(QPoint(r.x(), r.y() + r.height() // 2 - s2))
self.__THandle.moveTopLeft(QPoint(r.x() + r.width() // 2 - s2, r.y()))
self.__RHandle.moveTopRight(
QPoint(r.right(), r.y() + r.height() // 2 - s2))
self.__BHandle.moveBottomLeft(
QPoint(r.x() + r.width() // 2 - s2, r.bottom()))
def __handleMask(self, maskType):
"""
Private method to calculate the handle mask.
@param maskType type of the mask to be used
(SnapshotRegionGrabber.FillMask or
SnapshotRegionGrabber.StrokeMask)
@return calculated mask (QRegion)
"""
mask = QRegion()
for rect in self.__handles:
if maskType == SnapshotRegionGrabber.StrokeMask:
r = QRegion(rect)
mask += r.subtracted(QRegion(rect.adjusted(1, 1, -1, -1)))
else:
mask += QRegion(rect.adjusted(1, 1, -1, -1))
return mask
def __limitPointToRect(self, point, rect):
"""
Private method to limit the given point to the given rectangle.
@param point point to be limited (QPoint)
@param rect rectangle the point shall be limited to (QRect)
@return limited point (QPoint)
"""
q = QPoint()
if point.x() < rect.x():
q.setX(rect.x())
elif point.x() < rect.right():
q.setX(point.x())
else:
q.setX(rect.right())
if point.y() < rect.y():
q.setY(rect.y())
elif point.y() < rect.bottom():
q.setY(point.y())
else:
q.setY(rect.bottom())
return q
def __normalizeSelection(self, sel):
"""
Private method to normalize the given selection.
@param sel selection to be normalized (QRect)
@return normalized selection (QRect)
"""
rect = QRect(sel)
if rect.width() <= 0:
left = rect.left()
width = rect.width()
rect.setLeft(left + width - 1)
rect.setRight(left)
if rect.height() <= 0:
top = rect.top()
height = rect.height()
rect.setTop(top + height - 1)
rect.setBottom(top)
return rect
def __grabRect(self):
"""
Private method to grab the selected rectangle (i.e. do the snapshot).
"""
if self.__mode == SnapshotRegionGrabber.Ellipse:
ell = QRegion(self.__selection, QRegion.Ellipse)
if not ell.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - ell.boundingRect().x()
yOffset = self.__pixmap.rect().y() - ell.boundingRect().y()
translatedEll = ell.translated(xOffset, yOffset)
pixmap2 = QPixmap(ell.boundingRect().size())
pixmap2.fill(Qt.transparent)
pt = QPainter()
pt.begin(pixmap2)
if pt.paintEngine().hasFeature(QPaintEngine.PorterDuff):
pt.setRenderHints(
QPainter.Antialiasing |
QPainter.HighQualityAntialiasing |
QPainter.SmoothPixmapTransform,
True)
pt.setBrush(Qt.black)
pt.setPen(QPen(QBrush(Qt.black), 0.5))
pt.drawEllipse(translatedEll.boundingRect())
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(translatedEll)
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap,
ell.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
else:
r = QRect(self.__selection)
if not r.isNull() and r.isValid():
self.__grabbing = True
self.grabbed.emit(self.__pixmap.copy(r))
class Sprite:
def __init__(self, pos=None, sheet=None, parent=None, width=None, height=None):
if pos is None:
self.pos = Position(pos=[0, 0])
else:
self.pos = Position(pos=pos)
self.parent = parent
self.width = width
self.height = height
self.sheet = QPixmap(sheet)
self.pix = None
self.states = {'static':
{'pix' : [],
'delay' : 1000}}
self.state = 'static'
self.step = 0
self.delay = 50
self.timer = QTimer()
self.timer.timeout.connect(self.animate)
self.timer.setInterval(self.delay)
self.timer.start()
def set_sheet(self, sheet):
self.sheet = QPixmap(sheet)
def set_static(self, pix_pos=None, x_shift=None, y_shift=None, x_offset=0, y_offset=0,
z=1, scale=1.0):
if pix_pos is None:
pix_pos = Position()
else:
pix_pos = Position(pos=pix_pos)
if x_shift is None or y_shift is None:
self.states['static']['pix'].append(self.sheet)
else:
self.states['static']['pix'].append(self.sheet.copy(pix_pos.x(), pix_pos.y(), x_shift, y_shift))
self.pix = self.parent.m_scene.addPixmap(self.states['static']['pix'][0])
self.pix.setPos(self.pos.x(), self.pos.y())
self.pix.setOffset(x_offset, y_offset)
self.pix.setZValue(z)
self.pix.setScale(scale)
def move_sprite(self, pos):
self.pos.set(pos)
self.pix.setPos(self.pos.x(), self.pos.y())
def set_state(self, state):
self.state = state
self.timer.setInterval(self.states[state]['delay'])
self.step = 0
self.pix.setPixmap(self.states[state]['pix'][self.step])
def add_state(self, name, maps=[], delay=50):
self.states[name] = {}
self.states[name]['pix'] = maps
self.states[name]['delay'] = delay
def animate(self):
self.step += 1
if self.step >= len(self.states[self.state]['pix']):
self.step = 0
#print('step:', self.step)
self.pix.setPixmap(self.states[self.state]['pix'][self.step])
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.puzzleImage = QPixmap()
self.setupMenus()
self.setupWidgets()
self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.setWindowTitle("Puzzle")
def openImage(self, path=None):
if not path:
path, _ = QFileDialog.getOpenFileName(self, "Open Image", '',
"Image Files (*.png *.jpg *.bmp)")
if path:
newImage = QPixmap()
if not newImage.load(path):
QMessageBox.warning(self, "Open Image",
"The image file could not be loaded.",
QMessageBox.Cancel)
return
self.puzzleImage = newImage
self.setupPuzzle()
def setCompleted(self):
QMessageBox.information(self, "Puzzle Completed",
"Congratulations! You have completed the puzzle!\nClick OK "
"to start again.",
QMessageBox.Ok)
self.setupPuzzle()
def setupPuzzle(self):
size = min(self.puzzleImage.width(), self.puzzleImage.height())
self.puzzleImage = self.puzzleImage.copy((self.puzzleImage.width()-size)/2,
(self.puzzleImage.height() - size)/2, size, size).scaled(400,
400, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
random.seed(QCursor.pos().x() ^ QCursor.pos().y())
self.model.addPieces(self.puzzleImage)
self.puzzleWidget.clear()
def setupMenus(self):
fileMenu = self.menuBar().addMenu("&File")
openAction = fileMenu.addAction("&Open...")
openAction.setShortcut("Ctrl+O")
exitAction = fileMenu.addAction("E&xit")
exitAction.setShortcut("Ctrl+Q")
gameMenu = self.menuBar().addMenu("&Game")
restartAction = gameMenu.addAction("&Restart")
openAction.triggered.connect(self.openImage)
exitAction.triggered.connect(QApplication.instance().quit)
restartAction.triggered.connect(self.setupPuzzle)
def setupWidgets(self):
frame = QFrame()
frameLayout = QHBoxLayout(frame)
self.piecesList = QListView()
self.piecesList.setDragEnabled(True)
self.piecesList.setViewMode(QListView.IconMode)
self.piecesList.setIconSize(QSize(60,60))
self.piecesList.setGridSize(QSize(80,80))
self.piecesList.setSpacing(10)
self.piecesList.setMovement(QListView.Snap)
self.piecesList.setAcceptDrops(True)
self.piecesList.setDropIndicatorShown(True)
self.model = PiecesModel(self)
self.piecesList.setModel(self.model)
self.puzzleWidget = PuzzleWidget()
self.puzzleWidget.puzzleCompleted.connect(self.setCompleted,
Qt.QueuedConnection)
frameLayout.addWidget(self.piecesList)
frameLayout.addWidget(self.puzzleWidget)
self.setCentralWidget(frame)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.puzzleImage = QPixmap()
self.setupMenus()
self.setupWidgets()
self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.setWindowTitle("Puzzle")
def openImage(self, path=None):
if not path:
path, _ = QFileDialog.getOpenFileName(self, "Open Image", '',
"Image Files (*.png *.jpg *.bmp)")
if path:
newImage = QPixmap()
if not newImage.load(path):
QMessageBox.warning(self, "Open Image",
"The image file could not be loaded.",
QMessageBox.Cancel)
return
self.puzzleImage = newImage
self.setupPuzzle()
def setCompleted(self):
QMessageBox.information(self, "Puzzle Completed",
"Congratulations! You have completed the puzzle!\nClick OK "
"to start again.",
QMessageBox.Ok)
self.setupPuzzle()
def setupPuzzle(self):
size = min(self.puzzleImage.width(), self.puzzleImage.height())
self.puzzleImage = self.puzzleImage.copy(
(self.puzzleImage.width() - size)/2,
(self.puzzleImage.height() - size)/2, size, size).scaled(400, 400, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
self.piecesList.clear()
for y in range(5):
for x in range(5):
pieceImage = self.puzzleImage.copy(x*80, y*80, 80, 80)
self.piecesList.addPiece(pieceImage, QPoint(x,y))
random.seed(QCursor.pos().x() ^ QCursor.pos().y())
for i in range(self.piecesList.count()):
if random.random() < 0.5:
item = self.piecesList.takeItem(i)
self.piecesList.insertItem(0, item)
self.puzzleWidget.clear()
def setupMenus(self):
fileMenu = self.menuBar().addMenu("&File")
openAction = fileMenu.addAction("&Open...")
openAction.setShortcut("Ctrl+O")
exitAction = fileMenu.addAction("E&xit")
exitAction.setShortcut("Ctrl+Q")
gameMenu = self.menuBar().addMenu("&Game")
restartAction = gameMenu.addAction("&Restart")
openAction.triggered.connect(self.openImage)
exitAction.triggered.connect(QApplication.instance().quit)
restartAction.triggered.connect(self.setupPuzzle)
def setupWidgets(self):
frame = QFrame()
frameLayout = QHBoxLayout(frame)
self.piecesList = PiecesList()
self.puzzleWidget = PuzzleWidget()
self.puzzleWidget.puzzleCompleted.connect(self.setCompleted,
Qt.QueuedConnection)
frameLayout.addWidget(self.piecesList)
frameLayout.addWidget(self.puzzleWidget)
self.setCentralWidget(frame)
class MapWidget(QWidget):
stopSIG=pyqtSignal()
def __init__(self,winParent):
super(MapWidget, self).__init__()
self.winParent=winParent
self.initUI()
self.carx = 0.0
self.cary = 0.0
self.phax = 0.0
self.phay = 0.0
self.scale = 4.0
self.laser = []
def initUI(self):
layout=QGridLayout()
#self.setLayout(layout)
#self.setAutoFillBackground(True)
#p = self.palette()
#p.setColor(self.backgroundRole(), QColor('#0D488A'))
#self.setPalette(p)
#self.map = cv2.imread("resources/Nurburgrin800W3.png", cv2.IMREAD_GRAYSCALE)
# cv2.imshow("@@@",self.map)
# cv2.waitKey(0)
#self.map = cv2.resize(self.map, (WIDTH,HEIGHT))
#self.map = cv2.resize(self.map, (800, 668))
# image = QImage(self.map.data, self.map.shape[1], self.map.shape[0], self.map.shape[1], QImage.Format_Indexed8);
self.pixmap = QPixmap("resources/Nurburghrin800W3.png")
self.mapWidget = QLabel(self)
self.mapWidget.setPixmap(self.pixmap)
self.resize(WIDTH,HEIGHT)
self.setMinimumSize(WIDTH,HEIGHT)
def RTx(self, angle, tx, ty, tz):
RT = np.matrix([[1, 0, 0, tx], [0, math.cos(angle), -math.sin(angle), ty], [0, math.sin(angle), math.cos(angle), tz], [0,0,0,1]])
return RT
def RTy(self, angle, tx, ty, tz):
RT = np.matrix([[math.cos(angle), 0, math.sin(angle), tx], [0, 1, 0, ty], [-math.sin(angle), 0, math.cos(angle), tz], [0,0,0,1]])
return RT
def RTz(self, angle, tx, ty, tz):
RT = np.matrix([[math.cos(angle), -math.sin(angle), 0, tx], [math.sin(angle), math.cos(angle),0, ty], [0, 0, 1, tz], [0,0,0,1]])
return RT
def drawCircle(self, painter, centerX, centerY, color, size):
pen = QPen(color, size)
painter.setPen(pen)
brush = QBrush(Qt.SolidPattern)
brush.setColor(QColor(Qt.blue))
painter.setBrush(brush)
painter.drawEllipse(centerX, centerY, 5, 5)
def drawName(self, painter, posx, posy, color, size, name):
pen = QPen(color, size)
painter.setPen(pen)
px1 = posx - 10
py1 = posy - 10
# painter.drawLine(QPointF(posx - 5,posy + 5), QPointF(px1,py1))
# painter.drawLine(QPointF(px1,py1), QPointF(px1+10,py1))
painter.setFont(QFont("Ubuntu Mono",12, QFont.Bold))
painter.drawText(QPointF(px1, py1), name)
def paintEvent(self, e):
copy = self.pixmap.copy()
painter = QPainter(copy)
painter.translate(QPoint(self.width()/2, self.height()/2))
RTx = self.RTx(-pi, 0, 0, 0)
p = RTx*np.matrix([[self.carx], [self.cary], [1], [1]])
px = p.flat[0]*self.scale
py = p.flat[1]*self.scale
self.drawCircle(painter,px,py,Qt.blue,2)
self.drawName(painter,px,py,Qt.blue,1, "F1")
#Draw phantom
p = RTx*np.matrix([[self.phax], [self.phay], [1], [1]])
px = p.flat[0]*self.scale
py = p.flat[1]*self.scale
self.drawCircle(painter,px,py,Qt.black,2)
self.drawName(painter,px,py,Qt.black,1, "Pha")
self.mapWidget.setPixmap(copy)
painter.end()
def drawCar(self, painter):
carsize = 60
tiresize = carsize/5
pen = QPen(Qt.black, 1)
painter.setPen(pen)
# Connectors
painter.drawLine(QPointF(-carsize/5,carsize/5),QPointF(carsize/5, carsize/5))
# Chassis
painter.fillRect(-carsize/6,carsize/2,carsize/3,carsize/2,Qt.red)
painter.fillRect(-carsize/16,0,carsize/8,carsize,Qt.red)
painter.fillRect(-carsize/6,-carsize/24,carsize/3,carsize/12,Qt.red)
painter.fillRect(-carsize/8,carsize-carsize/96,carsize/4,carsize/12,Qt.red)
# Tires
painter.fillRect(-carsize/4,carsize/8,tiresize/2,tiresize,Qt.black)
painter.fillRect(carsize/4,carsize/8,-tiresize/2,tiresize,Qt.black)
painter.fillRect(-carsize/4,carsize-carsize/8,tiresize/2,tiresize,Qt.black)
painter.fillRect(carsize/4,carsize-carsize/8,-tiresize/2,tiresize,Qt.black)
def drawLasel(self, painter):
pen = QPen(QColor('#6897BB'), 2)
painter.setPen(pen)
for d in self.laser:
px = -d[0]*math.sin(d[1])*self.scale
py = d[0]*math.cos(d[1])*self.scale
painter.drawLine(QPointF(0,0),QPointF(py, px))
def drawArrow(self, painter, posx, posy, color, width):
if posx == 0.0 and posy == 0.0:
return
_width = self.width()
_height = self.height()
pen = QPen(color, width)
painter.setPen(pen)
# Calculate relative coordintaes of point
#px = _width/2*posx/10.0
#py = _height/2*posy/10.0
RTx = self.RTx(pi, 0, 0, 0)
RTz = self.RTz(pi/2, 0, 0, 0)
RT = RTx*RTz
p = RT*np.matrix([[posx], [posy], [1], [1]])
px = p.flat[0]*self.scale
py = p.flat[1]*self.scale
# Draw main line
painter.drawLine(QPointF(0,0),QPointF(px, py))
#print("PRE: ",posx, posy)
#print("POST: ",px,py)
# Draw sides
sidex = math.hypot(px, py)/5.0
sidey = math.hypot(px, py)/5.0
if px != 0.0:
ang = math.atan2(py,px)
else:
ang = math.pi/2.0
if posx >= 0.0:
px1 = px + sidex * math.cos(math.pi+ang-0.5)
py1 = py + sidey * math.sin(math.pi+ang-0.5)
px2 = px + sidex * math.cos(math.pi+ang+0.5)
py2 = py + sidey * math.sin(math.pi+ang+0.5)
else:
px1 = px - sidex * math.cos(ang-0.5)
py1 = py - sidey * math.sin(ang-0.5)
px2 = px - sidex * math.cos(ang+0.5)
py2 = py - sidey * math.sin(ang+0.5)
painter.drawLine(QPointF(px, py),QPointF(px1, py1))
painter.drawLine(QPointF(px, py),QPointF(px2, py2))
#print(px,py)
#print(px1,py1)
def drawTarget(self, painter, posx, posy):
if posx == 0.0 and posy == 0.0:
return
pen = QPen(Qt.yellow, 4)
painter.setPen(pen)
sx = posx - 0.25
sy = posy - 0.25
ex = posx + 0.25
ey = posy + 0.25
painter.drawLine(QPointF(-sx*self.scale,sy*self.scale),QPointF(-ex*self.scale,ey*self.scale))
painter.drawText( QPoint(-sx*self.scale+3,sy*self.scale), self.targetid );
sx = posx + 0.25
sy = posy - 0.25
ex = posx - 0.25
ey = posy + 0.25
painter.drawLine(QPointF(-sx*self.scale,sy*self.scale),QPointF(-ex*self.scale,ey*self.scale))
def setCarPos(self, x, y):
self.carx = x
self.cary = y
def setPhantomPos(self, x, y):
self.phax = x
self.phay = y
def setLaserValues(self, laser):
# Init laser array
if len(self.laser) == 0:
for i in range(laser.numLaser):
self.laser.append((0,0))
for i in range(laser.numLaser):
dist = laser.distanceData[i]/1000.0
angle = math.radians(i)
self.laser[i] = (dist, angle)
