def highlight(self, x, y):
# 高亮坐标(x,y)
# 返回两种颜色像素点的坐标列表
red_pixels = [] # 外圈
black_pixels = [] # 内圈
red_pixels += alg.draw_ellipse([[x - 4, y - 4], [x + 4, y + 4]])
red_pixels += alg.draw_ellipse([[x - 3, y - 3], [x + 3, y + 3]])
black_pixels += alg.draw_ellipse([[x - 2, y - 2], [x + 2, y + 2]])
black_pixels += alg.draw_ellipse([[x - 1, y - 1], [x + 1, y + 1]])
return red_pixels, black_pixels
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...) -> None:
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None: # mark
item_pixels = []
if self.item_type == 'line' and self.p_list:
item_pixels = alg.draw_line(self.p_list, self.algorithm)
elif self.item_type == 'polygon':
if self.end == 1:
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
else:
item_pixels = alg.draw_polyline(self.p_list, self.algorithm)
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
elif self.item_type == 'polyline':
item_pixels = alg.draw_polyline(self.p_list, self.algorithm)
elif self.item_type == 'pencil':
item_pixels = alg.draw_polyline(self.p_list, 'Bresenham')
elif self.item_type == 'clip': # 画一个矩形而已
x_min, y_min, x_max, y_max = self.p_list[0][0], self.p_list[0][
1], self.p_list[1][0], self.p_list[1][1]
item_pixels = alg.draw_polygon([[x_min, y_min], [x_min, y_max],
[x_max, y_max], [x_max, y_min]],
'Bresenham')
for p in item_pixels:
# painter.setPen(self.item_color)
pen = QPen(self.item_color, self.pen_width, Qt.SolidLine)
painter.setPen(pen)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
if self.p_list:
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.col)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
if (self.finish_draw == True):
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
else:
item_pixels = alg.draw_part_polygon(self.p_list,
self.algorithm)
for p in item_pixels:
painter.setPen(self.col)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'fill_polygon':
if (self.finish_draw == True):
item_pixels = alg.polygon_fill(self.p_list)
else:
item_pixels = alg.draw_part_polygon(self.p_list,
self.algorithm)
for p in item_pixels:
painter.setPen(self.col)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
for p in item_pixels:
painter.setPen(self.col)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
if (len(self.p_list) <= 3 and self.algorithm == 'B-spline'):
item_pixels = alg.draw_part_polygon(self.p_list, 'Bresenham')
else:
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.col)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
painter.setPen(self.color)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
painter.setPen(self.color)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
painter.setPen(self.color)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
cont_pixels = alg.draw_polygon(self.p_list, 'Bresenham')
painter.setPen(self.color)
for p in item_pixels:
painter.drawPoint(*p)
painter.setPen(QColor(0, 0, 255))
for p in cont_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'freedom':
item_pixels = []
for i in range(len(self.p_list) - 1):
item_pixels.extend(
alg.draw_line([self.p_list[i], self.p_list[i + 1]],
'Bresenham'))
painter.setPen(self.color)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def get_draw_pixels(self, p_list, algorithm):
# draw figure
result = []
if self.item_type == 'line':
result = alg.draw_line(p_list, algorithm)
elif self.item_type == 'dot_line':
result = alg.draw_dotted_line(p_list)
elif self.item_type == 'polygon':
# 画边
for i in range(0,len(p_list)-1):
result.extend(alg.draw_line([p_list[i],\
p_list[i+1]], algorithm))
elif self.item_type == 'ellipse':
result = alg.draw_ellipse(p_list)
elif self.item_type == 'curve':
result = alg.draw_curve(p_list, algorithm)
return result
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...) -> None:
painter.setPen(self.pen)
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'polygon':
if len(self.p_list) > 1:
print('start')
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
print('end')
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'ellipse':
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
item_pixels = alg.draw_ellipse([[min(x0, x1), max(y0, y1)], [max(x0, x1), min(y0, y1)]])
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
for p in self.p_list:
painter.drawPoint(*p)
elif self.item_type == 'rect':
painter.drawRect(self.boundingRect())
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
item_dict = {}
elif line[0] == 'saveCanvas':
save_name = line[1]
canvas = np.zeros([height, width, 3], np.uint8)
canvas.fill(255)
for item_type, p_list, algorithm, color in item_dict.values():
if item_type == 'line':
pixels = alg.draw_line(p_list, algorithm)
for x, y in pixels:
canvas[height - 1 - y, x] = color
elif item_type == 'polygon':
pixels = alg.draw_polygon(p_list, algorithm)
for x, y in pixels:
canvas[height - 1 - y, x] = color
elif item_type == 'ellipse':
pixels = alg.draw_ellipse(p_list)
for x, y in pixels:
canvas[height - 1 - y, x] = color
elif item_type == 'curve':
pixels = alg.draw_curve(p_list, algorithm)
for x, y in pixels:
canvas[height - 1 - y, x] = color
Image.fromarray(canvas).save(
os.path.join(output_dir, save_name + '.bmp'), 'bmp')
elif line[0] == 'setColor':
pen_color[0] = int(line[1])
pen_color[1] = int(line[2])
pen_color[2] = int(line[3])
elif line[0] == 'drawLine':
item_id = line[1]
x0 = int(line[2])
def start_export(self, length, width):
# TODO: 区分长宽
path = QFileDialog.getSaveFileName(
caption='导出画布',
filter='BMP图像 (*.bmp);;PNG图像 (*.png);;JPEG图像 (*.jpg)')
# print(path)
if path[0] != '':
canvas = np.zeros([width, length, 3], np.uint8)
canvas.fill(255)
for item in self.canvas_widget.item_dict.values():
if item.item_type == 'line':
pixels = alg.draw_line(item.p_list, item.algorithm)
temp_color = item.color.getRgb()
pen_color = np.zeros(3, np.uint8)
pen_color[0], pen_color[1], pen_color[2] = temp_color[
0], temp_color[1], temp_color[2]
for x, y in pixels:
if 0 <= x < length and 0 <= y < width:
canvas[y, x] = np.array(pen_color)
elif item.item_type == 'polygon':
pixels = alg.draw_polygon(item.p_list, item.algorithm)
temp_color = item.color.getRgb()
pen_color = np.zeros(3, np.uint8)
pen_color[0], pen_color[1], pen_color[2] = temp_color[
0], temp_color[1], temp_color[2]
for x, y in pixels:
if 0 <= x < length and 0 <= y < width:
canvas[y, x] = np.array(pen_color)
elif item.item_type == 'ellipse':
pixels = alg.draw_ellipse(item.p_list)
temp_color = item.color.getRgb()
pen_color = np.zeros(3, np.uint8)
pen_color[0], pen_color[1], pen_color[2] = temp_color[
0], temp_color[1], temp_color[2]
for x, y in pixels:
if 0 <= x < length and 0 <= y < width:
canvas[y, x] = np.array(pen_color)
elif item.item_type == 'curve':
pixels = alg.draw_curve(item.p_list, item.algorithm)
temp_color = item.color.getRgb()
pen_color = np.zeros(3, np.uint8)
pen_color[0], pen_color[1], pen_color[2] = temp_color[
0], temp_color[1], temp_color[2]
for x, y in pixels:
if 0 <= x < length and 0 <= y < width:
canvas[y, x] = np.array(pen_color)
elif item.item_type == 'freedom':
pixels = []
for i in range(len(item.p_list) - 1):
pixels.extend(
alg.draw_line([item.p_list[i], item.p_list[i + 1]],
'Bresenham'))
temp_color = item.color.getRgb()
pen_color = np.zeros(3, np.uint8)
pen_color[0], pen_color[1], pen_color[2] = temp_color[
0], temp_color[1], temp_color[2]
for x, y in pixels:
if 0 <= x < length and 0 <= y < width:
canvas[y, x] = np.array(pen_color)
if path[1] == 'BMP图像 (*.bmp)':
Image.fromarray(canvas).save(path[0], 'bmp')
elif path[1] == 'PNG图像 (*.png)':
Image.fromarray(canvas).save(path[0], 'png')
else:
Image.fromarray(canvas).save(path[0], 'jpeg', quality=95)
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
painter.setPen(self.temppen)
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
if len(self.p_list) >= 2:
#填充
if self.if_polygon_fill:
painter.setPen(self.fillpen)
for p in self.filled_list:
painter.drawPoint(*p)
painter.setPen(self.temppen)
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
x_min = min(x0, x1)
x_max = max(x0, x1)
y_min = min(y0, y1)
y_max = max(y0, y1)
self.temp_list = []
self.temp_list.append([x_min, y_max])
self.temp_list.append([x_max, y_min])
item_pixels = alg.draw_ellipse(self.temp_list)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
if len(self.p_list) >= 2:
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'Rect':
fake_p_list = []
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
fake_p_list.append([x0, y0])
fake_p_list.append([x0, y1])
fake_p_list.append([x1, y1])
fake_p_list.append([x1, y0])
item_pixels = alg.draw_polygon(fake_p_list, "DDA")
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon_cut':
if len(self.p_list) >= 4:
length = len(self.p_list)
xmin, ymin = self.p_list[length - 2]
xmax, ymax = self.p_list[length - 1]
temp_list = self.p_list[0:length - 2]
item_pixels = alg.draw_polygon_cut(temp_list, xmin, xmax, ymin,
ymax)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
for i in range(len(self.p_list)):
if type(self.p_list[i][0]) != int and type(
self.p_list[i][1]) != int:
# print(i)
# print("Hit error")
self.p_list[i] = list(self.p_list[i])
self.p_list[i][0] = int(self.p_list[i][0])
self.p_list[i][1] = int(self.p_list[i][1])
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
if self.finish_draw == True:
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
else:
item_pixels = alg.draw_polygoning(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
if (len(self.p_list) <= 3 and self.algorithm == 'B-spline'):
item_pixels = alg.draw_polygoning(self.p_list, 'DDA')
else:
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
#print("Hit drawing curve")
pass
elif self.item_type == 'free':
item_pixels = alg.draw_polygoning(self.p_list, 'DDA')
#item_pixels =self.p_list
for p in item_pixels:
painter.setPen(self.color)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
if self.item_type == 'helperPoints':
for point in self.p_list:
x, y = point[0], point[1]
painter.drawPoint(x, y)
painter.setPen(self.pointPen)
painter.drawLine(x - 2, y - 2, x - 2, y + 2)
painter.drawLine(x + 2, y - 2, x + 2, y + 2)
painter.drawLine(x - 2, y - 2, x + 2, y - 2)
painter.drawLine(x - 2, y + 2, x + 2, y + 2)
return
if self.item_type == 'helperLines':
painter.setPen(self.linePen)
for line in self.p_list:
painter.drawLine(line[0][0], line[0][1], line[1][0],
line[1][1])
return
elif self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
elif self.item_type == 'polygon':
item_pixels = []
for i in range(len(self.p_list) - 1):
line = alg.draw_line([self.p_list[i], self.p_list[i + 1]],
self.algorithm)
item_pixels += line
elif self.item_type == 'polygonDone':
item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
box = self.boundingRect()
if self.fill_color != Qt.transparent:
fill_pixels = alg.fillPolygon(self.p_list, int(box.x()),
int(box.y()),
int(box.x() + box.width()),
int(box.y() + box.height()))
pen2 = QPen()
pen2.setBrush(QColor(self.fill_color))
painter.setPen(pen2)
for p in fill_pixels:
painter.drawPoint(*p)
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
box = self.boundingRect()
if self.fill_color != Qt.transparent:
fill_pixels = alg.fillEllipse(item_pixels, int(box.y()),
int(box.y() + box.height()))
pen2 = QPen()
pen2.setBrush(QColor(self.fill_color))
painter.setPen(pen2)
for p in fill_pixels:
painter.drawPoint(*p)
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
pen = QPen()
pen.setWidth(self.width)
pen.setBrush(self.color)
painter.setPen(pen)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QPen(Qt.red, 1, Qt.DashLine))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
painter.setPen(self.color)
if self.item_type == 'line':
item_pixels = alg.draw_line(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'rectangle':
x1, y1 = self.p_list[0]
x2, y2 = self.p_list[1]
x_min = min(x1, x2)
x_max = max(x1, x2)
y_min = min(y1, y2)
y_max = max(y1, y2)
temp_plist = [[x_min, y_min], [x_min, y_max], [x_max, y_max],
[x_max, y_min]]
item_pixels = alg.draw_polygon(temp_plist,
self.algorithm,
label=True)
if self.fill:
item_pixels += alg.polygon_fill(temp_plist)
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'polygon':
item_pixels = alg.draw_polygon(self.p_list,
self.algorithm,
label=self.finished)
if self.fill:
item_pixels += alg.polygon_fill(self.p_list)
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'ellipse':
item_pixels = alg.draw_ellipse(self.p_list)
for p in item_pixels:
painter.drawPoint(*p)
elif self.item_type == 'curve':
item_pixels = alg.draw_curve(self.p_list, self.algorithm)
for p in item_pixels:
painter.drawPoint(*p)
if not self.finished or self.selected:
# 显示控制点
red_pixels = []
black_pixels = []
for x, y in self.p_list:
r, b = self.highlight(x, y)
red_pixels += r
black_pixels += b
for i in range(len(self.p_list) - 1):
red_pixels += alg.draw_line(
[self.p_list[i], self.p_list[i + 1]], 'DDA')
painter.setPen(QColor(255, 0, 0))
for p in red_pixels:
painter.drawPoint(*p)
painter.setPen(QColor(0, 0, 0))
for p in black_pixels:
painter.drawPoint(*p)
painter.setPen(self.color)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
def paint(self,
painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget] = ...) -> None:
if self.item_type == 'line':
p_list = self.p_list
if self.rotate_angle != 0:
p_list = alg.rotate(self.p_list, self.rotate_center[0],
self.rotate_center[1], self.rotate_angle)
if self.scale_ratio != 0:
p_list = alg.scale(self.p_list, self.scale_center[0],
self.scale_center[1], self.scale_ratio)
item_pixels = alg.draw_line(p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.paintColor)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'polygon':
p_list = self.p_list
if self.rotate_angle != 0:
p_list = alg.rotate(self.p_list, self.rotate_center[0],
self.rotate_center[1], self.rotate_angle)
if self.scale_ratio != 0:
p_list = alg.scale(self.p_list, self.scale_center[0],
self.scale_center[1], self.scale_ratio)
item_pixels = alg.draw_polygon(p_list, self.algorithm)
for p in item_pixels:
painter.setPen(self.paintColor)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'ellipse':
p_list = self.p_list
if self.scale_ratio != 0:
p_list = alg.scale(self.p_list, self.scale_center[0],
self.scale_center[1], self.scale_ratio)
item_pixels = alg.draw_ellipse(p_list)
for p in item_pixels:
painter.setPen(self.paintColor)
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'curve':
p_list = self.p_list
if self.rotate_angle != 0:
p_list = alg.rotate(self.p_list, self.rotate_center[0],
self.rotate_center[1], self.rotate_angle)
if self.scale_ratio != 0:
p_list = alg.scale(self.p_list, self.scale_center[0],
self.scale_center[1], self.scale_ratio)
item_pixels = alg.draw_curve(p_list, self.algorithm)
for p in p_list:
painter.setPen(self.paintColor)
painter.drawPoint(*p)
for p in item_pixels:
painter.drawPoint(*p)
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'select':
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
x = min(x0, x1)
y = min(y0, y1)
w = max(x0, x1) - x
h = max(y0, y1) - y
painter.setPen(QColor(0, 0, 255))
painter.drawRects(QRectF(x, y, w, h))
elif self.item_type == 'rect':
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
x = min(x0, x1)
y = min(y0, y1)
w = max(x0, x1) - x
h = max(y0, y1) - y
painter.setPen(self.paintColor)
painter.drawRects(QRectF(x, y, w, h))
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.boundingRect())
elif self.item_type == 'rotate':
painter.drawPoint(*(self.p_list[0]))
elif self.item_type == 'scale':
painter.drawPoint(*(self.p_list[0]))
elif self.item_type == 'clip':
x0, y0 = self.p_list[0]
x1, y1 = self.p_list[1]
x = min(x0, x1)
y = min(y0, y1)
w = max(x0, x1) - x
h = max(y0, y1) - y
painter.setPen(QColor(0, 0, 255))
painter.drawRects(QRectF(x, y, w, h))
def paint_small_cycle(painter, p_list):
for poi in p_list:
pixels = alg.draw_ellipse([[poi[0]-2,poi[1]-2],[poi[0]+2,poi[1]+2]])
for p in pixels:
painter.drawPoint(*p)
return
