def __init__(self, parent, row, col):
super(Board,self).__init__(parent)
self.x = -1
self.y = -1
self.piece = None
self.row = row
self.col = col
self.cellwidth = 50
self.linewidth = 1
self.width = self.cellwidth*col + self.linewidth*(col+1)
self.height = self.cellwidth*row + self.linewidth*(row+1)
self.setFixedSize(self.width, self.height)
self.board = QImage(self.width, self.height, QImage.Format_ARGB32)
self.pieces = QImage(self.width, self.height, QImage.Format_ARGB32)
p = QPainter(self.board)
p.setBrush(QColor(255, 255, 255, 255))
p.drawRect(QRect(0, 0, self.width-1, self.height-1))
linelist_x = [QLine(x, 0, x, self.height-1) for x in range(0, self.width, self.cellwidth+1)]
linelist_y = [QLine(0, y, self.width-1, y) for y in range(0, self.height, self.cellwidth+1)]
p.drawLines(linelist_x + linelist_y)
self.pieces.fill(0x000000FF)
self.setMouseTracking(True)
def paintEvent(event):
painter = QPainter(self.label_image)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
w = self.label_image.size().width()
h = self.label_image.size().height()
painter.scale(w / 80.0, h / 60.0)
painter.drawImage(0, 0, self.image)
if 35 != None and 45 != None:
pen = QPen()
pen.setColor(Qt.white)
pen.setWidth(0.2)
painter.setPen(pen)
from_x, from_y, to_x, to_y = [35, 25, 45, 35]
from_x = from_x * self.image_pixel_width + 1
from_y = from_y * self.image_pixel_width + 1
to_x = to_x * self.image_pixel_width + 1
to_y = to_y * self.image_pixel_width + 1
cross_x = from_x + (to_x - from_x) / 2.0
cross_y = from_y + (to_y - from_y) / 2.0
if to_x - from_x > 5 or to_y - from_y > 5:
lines = [
QLine(from_x, from_y, from_x + self.crosshair_width,
from_y),
QLine(from_x, from_y, from_x,
from_y + self.crosshair_width),
QLine(to_x, to_y, to_x, to_y - self.crosshair_width),
QLine(to_x, to_y, to_x - self.crosshair_width, to_y),
QLine(from_x, to_y, from_x,
to_y - self.crosshair_width),
QLine(from_x, to_y, from_x + self.crosshair_width,
to_y),
QLine(to_x, from_y, to_x,
from_y + self.crosshair_width),
QLine(to_x, from_y, to_x - self.crosshair_width,
from_y)
]
painter.drawLines(lines)
lines = [
QLine(cross_x - self.crosshair_width, cross_y,
cross_x + self.crosshair_width, cross_y),
QLine(cross_x, cross_y - self.crosshair_width, cross_x,
cross_y + self.crosshair_width)
]
painter.drawLines(lines)
self.update_spotmeter_roi_label()
def paintEvent( self, event ):
"""
Overloads the paint event to handle drawing the splitter lines.
:param event | <QPaintEvent>
"""
lines = []
count = 20
# calculate the lines
if ( self.orientation() == Qt.Vertical ):
x = self._resizeGrip.pos().x()
h = self.height()
spacing = int(float(self._resizeGrip.width()) / count)
for i in range(count):
lines.append(QLine(x, 0, x, h))
x += spacing
else:
y = self._resizeGrip.pos().y()
w = self.width()
spacing = int(float(self._resizeGrip.height()) / count)
for i in range(count):
lines.append(QLine(0, y, w, y))
y += spacing
# draw the lines
painter = QPainter()
painter.begin(self)
pal = self.palette()
painter.setPen(pal.color(pal.Window).darker(120))
painter.drawLines(lines)
painter.end()
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt4.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1,-1)
self._painter.translate(0,-canvas.height())
Renderer.set_canvas(self,canvas)
def _get_canvas_size(self,pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs,ys = zip(
transform.map(0.0,0.0),
transform.map(0.0,float(self.size[1])),
transform.map(float(self.size[0]),float(self.size[1])),
transform.map(float(self.size[0]),0.0)
)
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin//self._grid_spacing), int(xmax//self._grid_spacing + 1))
y_ticks = (int(ymin//self._grid_spacing), int(ymax//self._grid_spacing + 1))
self._painter.drawLines(
[QLineF(xmin, i * self._grid_spacing,
xmax, i * self._grid_spacing)
for i in range(*y_ticks)])
self._painter.drawLines(
[QLineF(i * self._grid_spacing, ymin,
i * self._grid_spacing, ymax)
for i in range(*x_ticks)])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor,factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx,dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0,0,self.size[0],self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self,color=0, thickness=0):
"""Sets the line color and thickness.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(QPen(self.__qcolor(color),thickness))
def set_brush(self,color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self,points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb = None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx-ra,cy-ra,2*ra,2*rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x,y,w,h))
def draw_text(self, text, x, y, bgcolor = 0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1,y1,x2,y2))
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt4.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1, -1)
self._painter.translate(0, -canvas.height())
Renderer.set_canvas(self, canvas)
def _get_canvas_size(self, pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs, ys = zip(transform.map(0.0, 0.0),
transform.map(0.0, float(self.size[1])),
transform.map(float(self.size[0]), float(self.size[1])),
transform.map(float(self.size[0]), 0.0))
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin // self._grid_spacing),
int(xmax // self._grid_spacing + 1))
y_ticks = (int(ymin // self._grid_spacing),
int(ymax // self._grid_spacing + 1))
self._painter.drawLines([
QLineF(xmin, i * self._grid_spacing, xmax, i * self._grid_spacing)
for i in range(*y_ticks)
])
self._painter.drawLines([
QLineF(i * self._grid_spacing, ymin, i * self._grid_spacing, ymax)
for i in range(*x_ticks)
])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor, factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx, dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0, 0, self.size[0], self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self, color):
"""Sets the line color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(self.__qcolor(color))
def set_brush(self, color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self, points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(
QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb=None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx - ra, cy - ra, 2 * ra, 2 * rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x, y, w, h))
def draw_text(self, text, x, y, bgcolor=0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1, y1, x2, y2))
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(
event.rect(),
self.image.scaledToWidth(self.width * self.image_pixel_width,
Qt.SmoothTransformation))
if self.agc_roi_from != None and self.agc_roi_to != None and not self.image_is_16bit:
pen = QPen()
pen.setColor(Qt.green)
pen.setWidth(1)
painter.setPen(pen)
roi = self.parent.get_agc_roi()
painter.drawRect(roi[0] * self.image_pixel_width + 1,
roi[1] * self.image_pixel_width + 1,
(roi[2] - roi[0]) * self.image_pixel_width + 1,
(roi[3] - roi[1]) * self.image_pixel_width + 1)
self.parent.update_agc_roi_label()
if self.spotmeter_roi_from != None and self.spotmeter_roi_to != None:
pen = QPen()
pen.setColor(Qt.white)
pen.setWidth(1)
painter.setPen(pen)
from_x, from_y, to_x, to_y = self.parent.get_spotmeter_roi()
from_x = from_x * self.image_pixel_width + 1
from_y = from_y * self.image_pixel_width + 1
to_x = to_x * self.image_pixel_width + 1
to_y = to_y * self.image_pixel_width + 1
cross_x = from_x + (to_x - from_x) / 2.0
cross_y = from_y + (to_y - from_y) / 2.0
if to_x - from_x > 5 or to_y - from_y > 5:
lines = [
QLine(from_x, from_y, from_x + self.crosshair_width,
from_y),
QLine(from_x, from_y, from_x,
from_y + self.crosshair_width),
QLine(to_x, to_y, to_x, to_y - self.crosshair_width),
QLine(to_x, to_y, to_x - self.crosshair_width, to_y),
QLine(from_x, to_y, from_x, to_y - self.crosshair_width),
QLine(from_x, to_y, from_x + self.crosshair_width, to_y),
QLine(to_x, from_y, to_x, from_y + self.crosshair_width),
QLine(to_x, from_y, to_x - self.crosshair_width, from_y)
]
painter.drawLines(lines)
lines = [
QLine(cross_x - self.crosshair_width, cross_y,
cross_x + self.crosshair_width, cross_y),
QLine(cross_x, cross_y - self.crosshair_width, cross_x,
cross_y + self.crosshair_width)
]
painter.drawLines(lines)
self.parent.update_spotmeter_roi_label()
