def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
if (tileWidth <= 0 or tileHeight <= 0):
return
startX = max(0, int(rect.x() / tileWidth) * tileWidth)
startY = max(0, int(rect.y() / tileHeight) * tileHeight)
endX = min(math.ceil(rect.right()), self.map().width() * tileWidth + 1)
endY = min(math.ceil(rect.bottom()),
self.map().height() * tileHeight + 1)
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
if (startY < endY):
gridPen.setDashOffset(startY)
painter.setPen(gridPen)
for x in range(startX, endX, tileWidth):
painter.drawLine(x, startY, x, endY - 1)
if (startX < endX):
gridPen.setDashOffset(startX)
painter.setPen(gridPen)
for y in range(startY, endY, tileHeight):
painter.drawLine(startX, y, endX - 1, y)
def drawForeground(self, painter, rect):
if self._tiling is None:
return
if self._showTileOutlines:
tile_nos = self._tiling.intersected(rect)
for tileId in tile_nos:
## draw tile outlines
# Dashed black line
pen = QPen()
pen.setWidth(0)
pen.setDashPattern([5, 5])
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
# Dashed white line
# (offset to occupy the spaces in the dashed black line)
pen = QPen()
pen.setWidth(0)
pen.setDashPattern([5, 5])
pen.setDashOffset(5)
pen.setColor(QColor(Qt.white))
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
if (tileWidth <= 0 or tileHeight <= 0):
return
startX = max(0, int(rect.x() / tileWidth) * tileWidth)
startY = max(0, int(rect.y() / tileHeight) * tileHeight)
endX = min(math.ceil(rect.right()), self.map().width() * tileWidth + 1)
endY = min(math.ceil(rect.bottom()), self.map().height() * tileHeight + 1)
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
if (startY < endY):
gridPen.setDashOffset(startY)
painter.setPen(gridPen)
for x in range(startX, endX, tileWidth):
painter.drawLine(x, startY, x, endY - 1)
if (startX < endX):
gridPen.setDashOffset(startX)
painter.setPen(gridPen)
for y in range(startY, endY, tileHeight):
painter.drawLine(startX, y, endX - 1, y)
def drawLine(self, startPos, endPos):
pen = QPen()
pen.setDashOffset(1)
pen.setWidth(2)
painter = QPainter(self.canvas)
painter.setPen(pen)
painter.drawLine(QPoint(startPos.x, startPos.y),
QPoint(endPos.x, endPos.y))
def drawForeground(self, painter, rect):
"""Draw the gridlines overlaying the canvas
:param painter: QPainter object to paint with
:type painter: QPainter
:param rect: Exposed rectangle to paint over
:type rect: QRectF
"""
pen = QPen(Qt.darkCyan)
pen.setWidth(0)
painter.setPen(pen)
thin_lines = []
thick_lines = []
for longitude in range(self.subject.width + 1):
line = QLineF(longitude, 0, longitude, self.subject.height)
if longitude % 8 == 0:
thick_lines.append(line)
thin_lines.append(line)
for latitude in range(self.subject.height + 1):
line = QLineF(0, latitude, self.subject.width, latitude)
if latitude % 8 == 0:
thick_lines.append(line)
thin_lines.append(line)
pen = QPen(Qt.darkCyan)
pen.setWidth(1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawLines(thin_lines)
pen.setColor(Qt.white)
painter.setPen(pen)
painter.drawLines(thick_lines)
if self.overlay.selecting:
pen = QPen(Qt.white)
pen.setJoinStyle(Qt.MiterJoin)
pen.setWidth(3)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(
QRectF(
self.overlay.start_scene_pos, self.overlay.cur_scene_pos
)
)
pen.setColor(Qt.black)
pen.setStyle(Qt.DotLine)
pen.setDashOffset(self.overlay.ants_offset)
painter.setPen(pen)
painter.drawRect(
QRectF(
self.overlay.start_scene_pos, self.overlay.cur_scene_pos
)
)
def paint(self, painter, arg2, arg3):
horizontal = [
QLineF(self.mBoundingRect.topRight(), self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.bottomLeft())]
vertical = [
QLineF(self.mBoundingRect.bottomLeft(), self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.topRight())]
dashPen = QPen(Qt.DashLine)
dashPen.setCosmetic(True)
dashPen.setDashOffset(max(0.0, self.x()))
painter.setPen(dashPen)
painter.drawLines(horizontal)
dashPen.setDashOffset(max(0.0, self.y()))
painter.setPen(dashPen)
painter.drawLines(vertical)
def paint(self, painter, option, widget=None):
"""
Paint a single line of the slice intersection marker.
"""
width = self._parent._width
height = self._parent._height
thickness = self._parent.PEN_THICKNESS
# Our pen thickness is consistent across zoom levels because the pen is "cosmetic"
# However, that doesn't ensure a consistent-size dash pattern.
# Determine the inverse scaling factor from scene to view to set a consistent dash pattern at all scales.
view = self.scene().views()[0]
inverted_transform, has_inverse = view.transform().inverted()
dash_length = old_div(4, inverted_transform.m11())
dash_length = max(0.5, dash_length)
# Draw the line with two pens to get a black-and-white dashed line.
# pen_white = QPen( Qt.white, thickness )
pen_white = QPen(self._parent._cropColor, thickness)
pen_white.setDashPattern([dash_length, dash_length])
pen_white.setCosmetic(True)
pen_black = QPen(Qt.black, thickness)
pen_black.setDashPattern([dash_length, dash_length])
pen_black.setCosmetic(True)
pen_black.setDashOffset(dash_length)
with painter_context(painter):
t = painter.transform()
painter.setTransform(self.scene().data2scene * t)
# Draw the line with two pens to get a black-and-white dashed line.
for pen in [pen_white, pen_black]:
painter.setPen(pen)
if self._direction == "horizontal":
painter.drawLine(QPointF(0.0, self.position), QPointF(width, self.position))
else:
painter.drawLine(QPointF(self.position, 0.0), QPointF(self.position, height))
def paint(self, painter, arg2, arg3):
horizontal = [
QLineF(self.mBoundingRect.topRight(),
self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(),
self.mBoundingRect.bottomLeft())
]
vertical = [
QLineF(self.mBoundingRect.bottomLeft(),
self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(),
self.mBoundingRect.topRight())
]
dashPen = QPen(Qt.DashLine)
dashPen.setCosmetic(True)
dashPen.setDashOffset(max(0.0, self.x()))
painter.setPen(dashPen)
painter.drawLines(horizontal)
dashPen.setDashOffset(max(0.0, self.y()))
painter.setPen(dashPen)
painter.drawLines(vertical)
def drawPath(self, items, useRows):
"""Draws one flight path
Args
items -- squares.
useRows:
True -- go by rows
False -- go by cols
"""
if useRows:
way = "row"
sortFirst = "col"
oldSide = "left"
newSide = "right"
color = QColor(255, 10, 10)
else:
way = "col"
sortFirst = "row"
oldSide = "top"
newSide = "bottom"
color = QColor(10, 255, 10)
# Pen for main lines
pen = QPen(color)
pen.setWidth(2)
pen.setCosmetic(True)
# Pen for turning lines
pen2 = QPen(color)
pen2.setWidth(2)
pen2.setStyle(Qt.DashLine)
pen2.setDashOffset(2)
pen2.setCosmetic(True)
# Sort selected items
items.sort(key=lambda item: item.getRowCol()[sortFirst])
items.sort(key=lambda item: item.getRowCol()[way])
def addItem(item):
self.addItem(item)
if useRows:
self.rowLines.append(item)
else:
self.colLines.append(item)
# Draw lines
newPos = True # Shows if we're will be at new col/row at next iteration
prevLine = None # Previously drawn line
isLastPointReversed = False # Shows from which end draw turning line
for i in range(len(items)):
item = items[i]
if newPos:
side1 = item.getSides()[oldSide]
newPos = False
pos = item.getRowCol()[way]
try:
nextPos = items[i + 1].getRowCol()[way]
except:
nextPos = pos + 1
if pos != nextPos:
side2 = item.getSides()[newSide]
lineF = QLineF(side1, side2)
line = QGraphicsLineItem(lineF)
line.setPen(pen)
addItem(line)
newPos = True
if prevLine != None:
if isLastPointReversed:
start = prevLine.p2()
end = side2
else:
start = prevLine.p1()
end = side1
newLine = QGraphicsLineItem(QLineF(start, end))
newLine.setPen(pen2)
addItem(newLine)
isLastPointReversed = not isLastPointReversed
prevLine = lineF
class Manipulator(Tool):
def __init__(self, canvas):
super(Manipulator, self).__init__(canvas)
self._name = 'Manipulator'
self._load_icon(":/icons/ico_sel_move", ":/icons/ico_sel_move_hover")
self._cursor = QPixmap(":/images/mover_cursor")
self._pressMousePos = QPoint()
self._lastMousePos = QPoint()
self._curMousePos = QPoint()
self._selectionRectangle = QRect()
self._selectionRectColor = QColor(255, 255, 255, 50)
self._selectionRectDashOffset = 0
self._selectionImage = None
self._cutOnSelection = True
self._doEraseOnSelectionMove = False
self._selectionBorderPen = QPen()
self._selectionBorderPen.setWidth(0)
self._selectionBorderPen.setStyle(Qt.DashLine)
self._selectionBorderPen.setColor(Qt.white)
self._selectionRectNodesPen = QPen()
self._selectionRectNodesPen.setWidth(0)
self._selectionRectNodesPen.setColor(Qt.white)
self._state = ManipulatorState.Idle
def draw_transformed(self, painter):
if not self._selectionRectangle.isEmpty():
painter.setPen(self._selectionBorderPen)
painter.setOpacity(1.0)
if self._selectionImage is None:
painter.setCompositionMode(QPainter.CompositionMode_Difference)
painter.fillRect(self._selectionRectangle, self._selectionRectColor)
painter.drawRect(self._selectionRectangle)
else:
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(self._selectionRectangle, self._selectionImage)
painter.setCompositionMode(QPainter.CompositionMode_Difference)
painter.drawRect(self._selectionRectangle)
print('Selection Rect Draw')
def draw_untransformed(self, painter):
canvas = self._canvas
x = canvas.mouse_state.global_pos.x() + 1
y = canvas.mouse_state.global_pos.y() + 1
if self._enablePointerDraw and self._state == ManipulatorState.Idle \
or self._state == ManipulatorState.MovingSelection \
or self._state == ManipulatorState.MovingPixels:
painter.drawPixmap(x - self._cursor.width() / 2, y -
self._cursor.height() / 2, self._cursor)
def update(self):
self._animate_selection_border()
def on_mouse_press(self):
super(Manipulator, self).on_mouse_press()
canvas = self._canvas
button = canvas.mouse_state.pressed_button
mouse_pos = canvas.mouse_state.canvas_pos
self._lastMousePos.setX(mouse_pos.x())
self._lastMousePos.setY(mouse_pos.y())
self._curMousePos.setX(mouse_pos.x())
self._curMousePos.setY(mouse_pos.y())
self._pressMousePos.setX(mouse_pos.x())
self._pressMousePos.setY(mouse_pos.y())
if button == Qt.LeftButton:
if self._selectionRectangle.isEmpty():
self._state = ManipulatorState.MovingPixels
else:
if self._selectionRectangle.contains(
QPoint(round(mouse_pos.x()), round(mouse_pos.y()))):
self._state = ManipulatorState.MovingSelection
else:
if self._selectionImage is not None:
self._paste_selection()
self._clear_selection()
self._state = ManipulatorState.Idle
elif button == Qt.RightButton:
if self._selectionImage is not None:
self._paste_selection()
self._clear_selection()
self._state = ManipulatorState.Selecting
def on_mouse_move(self):
canvas = self._canvas
mouse_pos = canvas.mouse_state.canvas_pos
if self._state == ManipulatorState.MovingPixels:
self._lastMousePos.setX(self._curMousePos.x())
self._lastMousePos.setY(self._curMousePos.y())
self._curMousePos.setX(mouse_pos.x())
self._curMousePos.setY(mouse_pos.y())
dx = self._curMousePos.x() - self._lastMousePos.x()
dy = self._curMousePos.y() - self._lastMousePos.y()
image = canvas.sprite_object.active_surface
if image is not None:
image_data = canvas.sprite_object.active_surface_pixel_data
if image_data is None:
return
quickpixler.movePixels(image_data, image.width(), image.height(), dx, dy)
self._canvas.surfaceChanging.emit()
elif self._state == ManipulatorState.Selecting:
top_left = QPoint(min(mouse_pos.x(), self._pressMousePos.x()),
min(mouse_pos.y(), self._pressMousePos.y()))
width = abs(mouse_pos.x() - self._pressMousePos.x())
height = abs(mouse_pos.y() - self._pressMousePos.y())
self._selectionRectangle.setRect(top_left.x(), top_left.y(),
width, height)
elif self._state == ManipulatorState.MovingSelection:
self._lastMousePos.setX(self._curMousePos.x())
self._lastMousePos.setY(self._curMousePos.y())
self._curMousePos.setX(mouse_pos.x())
self._curMousePos.setY(mouse_pos.y())
dx = self._curMousePos.x() - self._lastMousePos.x()
dy = self._curMousePos.y() - self._lastMousePos.y()
self._move_selection(dx, dy)
elif self._state == ManipulatorState.ScalingSelection:
pass
def on_mouse_release(self):
super(Manipulator, self).on_mouse_press()
if self._state == ManipulatorState.Selecting:
if not self._selectionRectangle.isEmpty():
self._copy_selection()
if self._cutOnSelection:
self._doEraseOnSelectionMove = True
elif self._state == ManipulatorState.MovingPixels:
self._canvas.surfaceChanged.emit()
self._state = ManipulatorState.Idle
def on_key_press(self, key):
if key == Qt.Key_Return:
if not self._selectionRectangle.isEmpty() and self._selectionImage is not None:
self._paste_selection()
self._clear_selection()
def _animate_selection_border(self):
self._selectionRectDashOffset += 1.0
if self._selectionRectDashOffset > 6.0:
self._selectionRectDashOffset = 0.0
self._selectionBorderPen.setDashOffset(self._selectionRectDashOffset)
def _clear_selection(self):
self._selectionRectangle = QRect()
self._selectionImage = None
def _normalize_selection_rect(self):
sprite_bounding_rect = self._canvas.sprite_object.bounding_rect_i
if self._selectionRectangle.left() < sprite_bounding_rect.left():
self._selectionRectangle.setLeft(sprite_bounding_rect.left())
if self._selectionRectangle.right() > sprite_bounding_rect.right():
self._selectionRectangle.setRight(sprite_bounding_rect.right())
if self._selectionRectangle.top() < sprite_bounding_rect.top():
self._selectionRectangle.setTop(sprite_bounding_rect.top())
if self._selectionRectangle.bottom() > sprite_bounding_rect.bottom():
self._selectionRectangle.setBottom(sprite_bounding_rect.bottom())
def _move_selection(self, dx, dy):
if self._doEraseOnSelectionMove:
self._erase_selection_below()
self._doEraseOnSelectionMove = False
if not self._selectionRectangle.isEmpty():
self._selectionRectangle.translate(dx, dy)
def _copy_selection(self):
self._normalize_selection_rect()
sprite_rect = self._canvas.map_global_rect_to_sprite_local_rect(self._selectionRectangle)
self._selectionImage = self._canvas.sprite_object.active_surface.copy(sprite_rect)
def _erase_selection_below(self):
sprite_rect_to_erase = self._canvas.map_global_rect_to_sprite_local_rect(
self._selectionRectangle)
drawing.erase_area(self._canvas.sprite_object.active_surface,
sprite_rect_to_erase.left(),
sprite_rect_to_erase.top(),
sprite_rect_to_erase.width(),
sprite_rect_to_erase.height())
self._canvas.surfaceChanged.emit()
def _paste_selection(self):
if self._selectionImage is None:
return
sprite_rect = self._canvas.map_global_rect_to_sprite_local_rect(self._selectionRectangle)
painter = QPainter()
painter.begin(self._canvas.sprite_object.active_surface)
painter.drawImage(sprite_rect, self._selectionImage, QRect(0, 0,
self._selectionImage.width(),
self._selectionImage.height()))
painter.end()
self._canvas.surfaceChanged.emit()
