def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'translate':
if self.selected_id != '':
temp_list = alg.translate(self.origin_list, x - self.x0, y - self.y0)
self.item_dict[self.selected_id].p_list = temp_list
elif self.status == 'rotate':
if self.selected_id != '':
if y != self.y0:
theta = math.atan(1.0 * (x - self.x0) / (y - self.y0)) * 180 / math.pi
temp_list = alg.rotate(self.origin_list, self.x0, self.y0, -int(theta))
self.item_dict[self.selected_id].p_list = temp_list
elif self.status == 'scale':
if self.selected_id != '':
t = ((x - self.x0) * (x - self.x0) + (y - self.y0) * (y - self.y0)) ** 0.5
t = t / 30
temp_list = alg.scale(self.origin_list, self.x0, self.y0, t)
self.item_dict[self.selected_id].p_list = temp_list
elif self.status == 'clip' or self.status == 'pclip':
if self.selected_id != '':
self.x1 = x
self.y1 = y
elif self.status == 'copy':
if self.selected_id != '':
temp_list = alg.translate(self.origin_list, x - self.x0, y - self.y0)
self.temp_item.p_list = temp_list
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def translate(self, dx, dy):
temp_list = alg.translate(self.p_list, dx, dy)
# temp_list_int = []
# for [x, y] in temp_list:
# temp_list_int.append([round(x), round(y)])
self.p_list = temp_list
if self.if_polygon_fill == True:
temp_list = alg.translate(self.filled_list, dx, dy)
self.filled_list = temp_list
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon':
self.temp_item.p_list[len(self.temp_item.p_list) - 1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'curve':
self.temp_item.p_list[len(self.temp_item.p_list) - 1] = [x, y]
elif self.status == 'translate':
self.item_dict[self.selected_id].p_list = alg.translate(self.item_dict[self.selected_id].p_list, x - self.temp_loc[0], y - self.temp_loc[1])
self.item_dict[self.selected_id].update()
self.temp_loc = [x, y]
elif self.status == 'rotate' :
x0 = x - self.temp_loc[0]
y0 = y - self.temp_loc[1]
r = self.temp_r - alg.cal_r(x0, y0)
self.item_dict[self.selected_id].p_list = alg.rotate(self.temp_list, self.temp_loc[0], self.temp_loc[1], int(r * 180 / math.pi))
self.item_dict[self.selected_id].update()
elif self.status == 'scale' :
x0 = x - self.temp_loc[0]
y0 = y - self.temp_loc[1]
r = (x0 * x0 + y0 * y0) ** 0.5
self.item_dict[self.selected_id].p_list = alg.scale(self.temp_list, self.temp_loc[0], self.temp_loc[1], r / self.temp_dis)
self.item_dict[self.selected_id].update()
elif self.status == 'clip':
self.clip_loc = [x, y]
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def transform(self, t_type, **kwargs):
if self.selected_id:
p_type = self.selected_item.item_type
p_list = self.selected_item.p_list
center = self.selected_item.rectCenter(
) if 'center' not in kwargs else kwargs['center']
isset = kwargs['set'] if 'set' in kwargs else False
ret = []
if t_type == 'translate':
ret = alg.translate(
p_list.real, kwargs['dx'], kwargs['dy'])
elif t_type == 'rotate':
ret = deepcopy(p_list)
ret.rotate(center, kwargs['r']) if p_type != 'ellipse' else ret
elif t_type == 'scale':
ret = deepcopy(p_list)
if isset:
ret.scale_set(center, kwargs['sx'], kwargs['sy'])
else:
ret.scale(center, kwargs['sx'], kwargs['sy'])
elif t_type == 'clip':
ret = alg.clip(
p_list.real, *kwargs['box'], kwargs['algorithm'])
if not ret:
ret = QMessageBox.warning(self, '警告', '未裁剪有效部分，将移除该线段。\n是否裁剪？',
QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Cancel)
if ret == QMessageBox.Ok:
self.remove_selected_item()
self.updateScene([self.sceneRect()])
return
self.stack.do(Action(
Action.TRANSFORM, item_id=self.selected_id, p_list=[deepcopy(p_list), deepcopy(ret)], t_type=t_type))
self.selected_item.p_list = PList(ret)
self.selected_item.noticeUpdate()
self.updateScene([self.sceneRect()])
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
#TODO
elif self.status == 'polygon':
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'curve':
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'translate':
self.temp_item.p_list = alg.translate(self.pList, x - self.select_xy[0], y - self.select_xy[1])
elif self.status == 'rotate':
pass
elif self.status == 'scale':
pass
elif self.status == 'clip':
self.temp_item.p_list = alg.clip(self.pList, self.select_xy[0], self.select_xy[1], x, y, self.temp_algorithm)
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
if self.status == 'ellipse':
if self.temp_item == None:
print("Hit Here")
pass
self.temp_item.p_list[1] = [x, y]
if self.status == "polygon":
# save the last position mouse stay
# and make Item move as mouse did
# Here Hit crash at one time
if self.temp_item == None:
pass
else:
self.temp_item.p_list[-1] = [x, y]
if self.status == "translate":
self.temp_item.p_list = alg.translate(self.temp_p_list,
x - self.start_point[0],
y - self.start_point[1])
if self.status == "scale":
xp = ((x - self.start_point[0])**2 +
(y - self.start_point[1])**2) / 10000
# print("缩放倍数：",xp)
self.temp_item.p_list = alg.scale(self.temp_p_list,
self.start_point[0],
self.start_point[1], xp)
if self.status == 'clip_LB' or self.status == 'clip_CS':
x_1 = min(self.start_point[0], x)
x_2 = max(self.start_point[0], x)
y_1 = min(self.start_point[1], y)
y_2 = max(self.start_point[1], y)
self.temp_item1.p_list = [[x_1, y_1], [x_1, y_2], [x_2, y_2],
[x_2, y_1], [x_1, y_1]]
if self.status == 'clip_LB':
self.temp_item.p_list = alg.clip(self.temp_p_list,
self.start_point[0],
self.start_point[1], x, y,
"Liang-Barsky")
else:
self.temp_item.p_list = alg.clip(self.temp_p_list,
self.start_point[0],
self.start_point[1], x, y,
"Cohen-Sutherland")
if self.status == "curve":
if self.temp_item == None:
pass
else:
self.temp_item.p_list[-1] = [x, y]
if self.status == 'free':
if self.temp_item == None:
print("Hit Here")
pass
self.temp_item.p_list.append([x, y])
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
if (self.temp_item == None):
pass
else:
self.temp_item.p_list[1] = [x, y]
elif self.status == 'ellipse':
if (self.temp_item == None):
pass
else:
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon':
if (self.temp_item == None):
pass
else:
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'fill_polygon':
if (self.temp_item == None):
pass
else:
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'curve':
if (self.temp_item == None):
pass
else:
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'translate':
self.temp_item.p_list = alg.translate(self.plist,
x - self.start_xy[0],
y - self.start_xy[1])
elif self.status == 'scale':
s = ((x - self.start_xy[0])**2 + (y - self.start_xy[1])**2) / 10000
self.temp_item.p_list = alg.scale(self.plist, self.start_xy[0],
self.start_xy[1], s)
elif self.status == 'clip':
self.temp_item.p_list = alg.clip(self.plist, self.start_xy[0],
self.start_xy[1], x, y,
self.temp_algorithm)
elif self.status == 'polygon_clip':
self.temp_item.p_list = alg.polygon_clip(self.plist,
self.start_xy[0],
self.start_xy[1], x, y)
self.updateScene([self.sceneRect()])
#self.prepareGeometryChange()
super().mouseMoveEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.temp_item is not None:
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon':
length = len(self.temp_item.p_list)
self.temp_item.p_list[length - 1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'curve':
length = len(self.temp_item.p_list)
self.temp_item.p_list[length - 1] = [x, y]
elif self.status == 'select':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'rect':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'move':
dx = x - self.temp_item.p_list[0][0]
dy = y - self.temp_item.p_list[0][1]
self.temp_item.p_list[0] = [x, y]
for item in self.selected_items:
item.p_list = alg.translate(item.p_list, dx, dy)
elif self.status == 'rotate':
if self.temp_item is not None and len(
self.temp_item.p_list) == 2:
x0, y0 = self.temp_item.p_list[0]
x1, y1 = self.temp_item.p_list[1]
v1 = [x1 - x0, y1 - y0]
v2 = [x - x0, y - y0]
angle = getAngle(v1, v2)
for item in self.selected_items:
item.rotate_angle = angle
elif self.status == 'scale':
if self.temp_item is not None and len(
self.temp_item.p_list) == 2:
x0, y0 = self.temp_item.p_list[0]
x1, y1 = self.temp_item.p_list[1]
ratio = (x - x0) / (x1 - x0)
for item in self.selected_items:
item.scale_ratio = ratio
elif self.status == 'clip':
self.temp_item.p_list[1] = [x, y]
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def start_paste(self, item_id):
self.status = 'paste'
self.temp_id = self.main_window.get_id()
self.temp_item = MyItem(self.temp_id,
self.clip_item.item_type,
self.clip_item.p_list,
self.clip_item.algorithm,
color=self.clip_item.color,
fill=self.clip_item.fill)
self.temp_item.finished = True
self.temp_item.p_list = alg.translate(self.temp_item.p_list, 15, 15)
self.item_dict[self.temp_id] = self.temp_item
self.scene().addItem(self.temp_item)
self.selection_changed(self.temp_item.id)
self.updateScene([self.sceneRect()])
self.finish_draw()
self.finish_edit()
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if event.buttons() == QtCore.Qt.LeftButton:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = self.height - 1 - int(pos.y())
if self.status == 'line' or self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'translate':
self.temp_item.p_list = alg.translate(self.p_list_copy,
x - self.xcenter,
y - self.ycenter)
elif self.status == 'rotate':
if self.xstart == -1:
self.xstart = x
self.ystart = y
else:
a = self.xstart - self.xcenter
b = self.ystart - self.ycenter
c = x - self.xcenter
d = y - self.ycenter
diff = a * d - b * c
Cos = (a * c +
b * d) / math.sqrt(a * a +
b * b) / math.sqrt(c * c + d * d)
angle = math.acos(Cos) / math.pi * 180
if diff < 0:
angle = 360 - angle
angle = 360 - angle
self.temp_item.p_list = alg.rotate(self.p_list_copy,
self.xcenter,
self.ycenter, angle)
elif self.status == 'scale':
s = max(0.1, 1.0 + (x - self.xcenter) / self.w)
self.temp_item.p_list = alg.scale(self.p_list_copy,
self.xcenter, self.ycenter,
s)
elif self.status == 'clip':
self.xstart = x
self.ystart = y
self.rb.setGeometry(
QRect(self.origin, event.pos()).normalized())
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line' or self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon' or self.status == 'curve':
self.temp_p_list[len(self.temp_p_list) - 1] = [x, y]
# self.temp_item.p_list = self.temp_p_list
elif self.status == 'translate':
self.temp_ctrl[1] = [x, y]
if self.selected_id != '':
dx = self.temp_ctrl[1][0] - self.temp_ctrl[0][0]
dy = self.temp_ctrl[1][1] - self.temp_ctrl[0][1]
print(dx, dy)
self.item_dict[self.selected_id].p_list = alg.translate(
self.temp_p_list, dx, dy)
elif self.status == 'rotate':
self.temp_ctrl[1] = [x, y]
if self.selected_id != '':
va = [
self.temp_ctrl[0][0] - self.cx,
self.temp_ctrl[0][1] - self.cy
]
vb = [
self.temp_ctrl[1][0] - self.cx,
self.temp_ctrl[1][1] - self.cy
]
angle1 = math.atan2(va[1], va[0])
angle2 = math.atan2(vb[1], vb[0])
angle = angle2 - angle1
r = angle * 180 / math.pi
print(r)
self.item_dict[self.selected_id].p_list = alg.rotate(
self.temp_p_list, self.cx, self.cy, r)
pass
elif self.status == 'scale':
self.temp_ctrl[1] = [x, y]
pass
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mousePressEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.main_window.col)
self.scene().addItem(self.temp_item)
elif self.status == 'ellipse':
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.main_window.col)
self.scene().addItem(self.temp_item)
elif self.status == 'polygon':
if (self.temp_item == None):
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.setbar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.main_window.col)
self.scene().addItem(self.temp_item)
else:
x0, y0 = self.temp_item.p_list[0]
if (((x0 - x)**2 + (y0 - y)**2) < 40
and len(self.temp_item.p_list) >= 3):
self.temp_item.finish_draw = True
self.item_dict[self.temp_id] = self.temp_item
self.list_widget.addItem(self.temp_id)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.setbar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.finish_draw()
self.save()
else:
self.temp_item.p_list.append([x, y])
elif self.status == 'fill_polygon':
if (self.temp_item == None):
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.setbar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], 'Bresenham',
self.main_window.col)
self.scene().addItem(self.temp_item)
else:
x0, y0 = self.temp_item.p_list[0]
if (((x0 - x)**2 + (y0 - y)**2) < 40
and len(self.temp_item.p_list) >= 3):
self.temp_item.finish_draw = True
self.item_dict[self.temp_id] = self.temp_item
self.list_widget.addItem(self.temp_id)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.setbar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.finish_draw()
self.save()
else:
self.temp_item.p_list.append([x, y])
elif self.status == 'curve':
if (self.temp_item == None):
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.main_window.col)
self.scene().addItem(self.temp_item)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.setbar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
else:
self.temp_item.p_list.append([x, y])
elif self.status == 'translate':
self.start_xy = [x, y]
elif self.status == 'rotate':
if event.button() == Qt.LeftButton:
self.start_xy = [x, y]
else:
self.plist = self.temp_item.p_list
self.status = ''
elif self.status == 'scale':
self.start_xy = [x, y]
elif self.status == 'clip' or self.status == 'polygon_clip':
self.start_xy = [x, y]
elif self.status == 'select':
selected = self.scene().itemAt(pos, QtGui.QTransform())
for item in self.item_dict:
if (self.item_dict[item] == selected):
if self.selected_id != '':
self.item_dict[self.selected_id].selected = False
self.item_dict[self.selected_id].update()
self.updateScene([self.sceneRect()])
self.selected_id = item
self.item_dict[item].selected = True
self.item_dict[item].update()
self.main_window.list_widget.setCurrentRow(int(item))
elif self.status == 'paste':
if (self.copy_id == ''):
self.updateScene([self.sceneRect()])
super().mousePressEvent(event)
return
self.copy_item = self.item_dict[self.copy_id]
self.temp_item = MyItem(self.temp_id, self.copy_item.item_type,
self.copy_item.p_list,
self.copy_item.algorithm,
self.main_window.col)
self.temp_item.finish_draw = True
num = 0
self.cpx = 0
self.cpy = 0
for xx, yy in self.copy_item.p_list:
self.cpx += xx
self.cpy += yy
num += 1
self.cpx = int(self.cpx / num)
self.cpy = int(self.cpy / num)
self.temp_item.p_list = alg.translate(self.copy_item.p_list,
x - self.cpx, y - self.cpy)
self.scene().addItem(self.temp_item)
self.item_dict[self.temp_id] = self.temp_item
self.list_widget.addItem(self.temp_id)
self.finish_draw()
self.save()
self.updateScene([self.sceneRect()])
super().mousePressEvent(event)
elif line[i] == 'B-spline':
algorithm = 'B-spline'
else:
p_list.append((int(line[i]), int(line[i + 1])))
i = i + 1
i = i + 1
item_dict[item_id] = [
'curve', p_list, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
id = line[1]
x0 = int(line[2])
y0 = int(line[3])
item_type, p_list, algorithm, color = item_dict[id]
pixels = alg.translate(p_list, x0, y0)
item_dict[id] = [item_type, pixels, algorithm, color]
elif line[0] == 'rotate':
id = line[1]
x0 = int(line[2])
y0 = int(line[3])
r = int(line[4])
item_type, p_list, algorithm, color = item_dict[id]
pixels = alg.rotate(p_list, x0, y0, r)
item_dict[id] = [item_type, pixels, algorithm, color]
elif line[0] == 'scale':
id = line[1]
x0 = int(line[2])
y0 = int(line[3])
s = float(line[4])
item_type, p_list, algorithm, color = item_dict[id]
def item_translate(self, p_list, dx, dy):
self.prepareGeometryChange()
self.p_list = alg.translate(p_list, dx, dy)
elif line[0] == 'drawCurve':
item_id = line[1]
pointSet = []
for i in range(2, len(line)-1, 2):
pointSet += [[int(line[i]),int(line[i+1])]]
algorithm = line[-1]
item_dict[item_id] = ['curve', pointSet, algorithm, np.array(pen_color)]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
item_type = item_dict[item_id][0]
pointSet = item_dict[item_id][1]
algorithm = item_dict[item_id][2]
color = item_dict[item_id][3]
pointSet = alg.translate(pointSet, dx, dy)
item_dict[item_id] = [item_type, pointSet, algorithm, color]
elif line[0] == 'rotate':
item_id = line[1]
x = int(line[2])
y = int(line[3])
r = int (line[4])
item_type = item_dict[item_id][0]
pointSet = item_dict[item_id][1]
algorithm = item_dict[item_id][2]
color = item_dict[item_id][3]
pointSet = alg.rotate(pointSet, x, y, r)
item_dict[item_id] = [item_type, pointSet, algorithm, color]
elif line[0] == 'scale':
item_id = line[1]
x = int(line[2])
y1 = int(line[5])
item_dict[item_id] = ['ellipse', [[x0, y0], [x1, y1]], None, np.array(pen_color)]
elif line[0] == 'drawCurve':
item_id = line[1]
p_list = []
n=len(line)
for i in range(1, int(n/2)):
p_list.append((int(line[2*i]),int(line[2*i+1])))
algorithm=line[n-1]
item_dict[item_id] = ['curve', p_list, algorithm, np.array(pen_color)]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
item_type, p_list, algorithm, color = item_dict[item_id]
p_list = alg.translate(p_list, dx, dy)
item_dict[item_id] = item_type, p_list, algorithm, color
elif line[0] == 'rotate':
item_id = line[1]
x = int(line[2])
y = int(line[3])
r = int(line[4])
item_type, p_list, algorithm, color = item_dict[item_id]
p_list = alg.rotate(p_list, x, y, r)
item_dict[item_id] = item_type, p_list, algorithm, color
elif line[0] == 'scale':
item_id = line[1]
x = int(line[2])
y = int(line[3])
s = float(line[4])
item_type, p_list, algorithm, color = item_dict[item_id]
elif line[0] == 'drawCurve':
item_id = line[1]
p_list = []
for i in range(0, int((len(line) - 3) / 2)):
p_list.append([int(line[2 + 2 * i]), int(line[3 + 2 * i])])
algorithm = line[len(line) - 1]
item_dict[item_id] = [
'curve', p_list, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
temp_item = item_dict.pop(item_id)
temp_item[1] = alg.translate(temp_item[1], dx, dy)
item_dict[item_id] = temp_item
elif line[0] == 'rotate':
item_id = line[1]
x = int(line[2])
y = int(line[3])
r = int(line[4])
temp_item = item_dict.pop(item_id)
temp_item[1] = alg.rotate(temp_item[1], x, y, r)
item_dict[item_id] = temp_item
elif line[0] == 'scale':
item_id = line[1]
x = int(line[2])
y = int(line[3])
s = float(line[4])
temp_item = item_dict.pop(item_id)
for x, y in pixels:
canvas[y, x] = color
elif item_type == 'curve':
pixels = alg.draw_curve(p_list, algorithm)
if pixels is not None:
for x, y in pixels:
canvas[y, x] = color
else:
item_type = item_type.strip().split(' ')
if item_type[0] == 'translate':
pixels = []
newpixels = []
dx = int(item_type[1])
dy = int(item_type[2])
newpixels = alg.translate(
p_list, dx, dy, algorithm,
item_type[len(item_type) - 1])
if newpixels is not None:
for x, y in newpixels:
canvas[y, x] = color
elif item_type[0] == 'rotate':
pixels = []
newpixels = []
x = int(item_type[1])
y = int(item_type[2])
r = int(item_type[3])
newpixels = alg.rotate(
p_list, x, y, r, algorithm,
item_type[len(item_type) - 1])
if newpixels is not None:
for x, y in newpixels:
np.array(pen_color)
]
elif line[0] == 'drawCurve':
item_id = line[1]
length = len(line)
algorithm = line[length - 1]
plist = []
for i in range(2, length - 1):
if i % 2 == 1:
plist.append([int(line[i - 1]), int(line[i])])
item_dict[item_id] = [
'curve', plist, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
plist = alg.translate(item_dict[line[1]][1], int(line[2]),
int(line[3]))
item_dict[line[1]][1] = plist
elif line[0] == 'rotate':
# 椭圆不需要旋转
if item_dict[line[1]][0] == 'ellipse':
line = fp.readline()
continue
plist = alg.rotate(item_dict[line[1]][1], int(line[2]),
int(line[3]), -1 * int(line[4]))
item_dict[line[1]][1] = plist
elif line[0] == 'scale':
plist = alg.scale(item_dict[line[1]][1], int(line[2]),
int(line[3]), float(line[4]))
item_dict[line[1]][1] = plist
elif line[0] == 'clip':
x_min = min(int(line[2]), int(line[4]))
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
if self.temp_item:
self.temp_item.p_list[1] = [x, y]
elif self.status == 'rectangle':
if self.temp_item:
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon':
if self.temp_item:
x0, y0 = self.temp_item.p_list[0]
if math.sqrt((x - x0)**2 + (y - y0)**2) <= 10 and len(
self.temp_item.p_list) >= 4:
self.temp_item.p_list.pop(len(self.temp_item.p_list) - 1)
self.temp_item.finished = True
self.item_dict[self.temp_id] = self.temp_item
self.finish_draw()
else:
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'ellipse':
if self.temp_item:
self.temp_item.p_list[1] = [x, y]
elif self.status == 'curve':
if self.temp_item:
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'translate_p1':
pass
elif self.status == 'translate_p2':
if self.temp_coordinate:
sx, sy = self.temp_coordinate
self.temp_item.p_list = alg.translate(self.temp_plist, x - sx,
y - sy)
elif self.status == 'rotate':
self.rotate_end = [x, y]
# 计算向量夹角
sx, sy = self.rotate_start
ex, ey = self.rotate_end
cx, cy = self.rotate_center
vec1 = np.array([sx - cx, sy - cy])
vec2 = np.array([ex - cx, ey - cy])
len1 = np.sqrt(vec1.dot(vec1))
len2 = np.sqrt(vec2.dot(vec2))
r = np.arccos(vec1.dot(vec2) / (len1 * len2))
angle = int(math.degrees(r) + 0.5)
if sx == ex:
if sy < ey and cx > sx:
angle = 360 - angle
elif sy > ey and cx < sx:
angle = 360 - angle
else:
k = (ey - sy) / (ex - sx)
b = sy - k * sx
if sx > ex and cy > k * cx + b:
angle = 360 - angle
elif sx < ex and cy < k * cx + b:
angle = 360 - angle
if self.temp_item:
self.temp_item.p_list = alg.rotate(self.temp_plist,
self.rotate_center[0],
self.rotate_center[1],
-angle)
elif self.status == 'scale':
self.scale_end = [x, y]
# 计算向量夹角
sx, sy = self.scale_start
ex, ey = self.scale_end
cx, cy = self.scale_center
s = math.sqrt((ex - sx)**2 + (ey - sy)**2) / 80
if self.temp_item:
self.temp_item.p_list = alg.scale(self.temp_plist, cx, cy, s)
elif self.status == 'clip':
sx, sy = self.temp_coordinate
if self.temp_item:
self.temp_item.p_list = alg.clip(self.temp_plist, sx, sy, x, y,
self.temp_algorithm)
elif self.status == 'polygon_clip':
sx, sy = self.temp_coordinate
if self.temp_algorithm == 'Sutherland-Hodgman':
if self.temp_item:
self.temp_item.p_list = alg.polygon_clip(
self.temp_plist, sx, sy, x, y, self.temp_algorithm)
elif self.status == '':
pass
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mousePressEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
#print(self.status,self.temp_item)
if self.status == 'line':
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.col)
self.scene().addItem(self.temp_item)
elif self.status == 'ellipse':
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.col)
self.scene().addItem(self.temp_item)
elif self.status == "polygon":
if self.temp_item == None:
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.col)
self.scene().addItem(self.temp_item)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.drawing = True
else:
if self.mousePressDetect(event) == 1:
self.temp_item.p_list.append([x, y])
else:
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.drawing = False
self.list_widget.addItem(self.temp_id)
self.temp_item.finish_draw = True
self.item_dict[self.temp_id] = self.temp_item
self.finish_draw()
# as soon as press right buttom which means stop
# I will refresh scene to use drawPolygon instead
# drawPolygoning which will draw last edge
self.updateScene([self.sceneRect()])
elif self.status == 'curve':
if self.temp_item == None:
self.temp_item = MyItem(self.temp_id, self.status,
[[x, y], [x, y]], self.temp_algorithm,
self.col)
self.scene().addItem(self.temp_item)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.drawing = True
else:
if self.mousePressDetect(event) == 1:
self.temp_item.p_list.append([x, y])
else:
self.list_widget.addItem(self.temp_id)
self.temp_item.finish_draw = True
self.item_dict[self.temp_id] = self.temp_item
self.finish_draw()
self.drawing = False
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
# as soon as press right buttom which means stop
# I will refresh scene to use drawPolygon instead
# drawPolygoning which will draw last edge
self.updateScene([self.sceneRect()])
elif self.status == "selecting":
selected = self.scene().itemAt(pos, QTransform())
for i in self.item_dict:
if self.item_dict[i] == selected:
if self.selected_id != "":
self.item_dict[self.selected_id].selected = False
self.item_dict[self.selected_id].update()
self.updateScene([self.sceneRect()])
self.selected_id = i
self.item_dict[i].selected = True
self.item_dict[i].update()
self.main_window.list_widget.setCurrentRow(int(i))
elif self.status == "translate":
if self.mousePressDetect(event) == 1:
self.start_point = [x, y]
elif self.status == "rotate":
# use left buttom to decide rotate center
# and use right buttom to caculate rotate angle
if self.mousePressDetect(event) == 1:
if self.rotating_flag == False:
self.start_point = [x, y]
self.rotating_flag = True
else:
pass
else:
# finish rotating
self.rotating_flag = False
self.temp_p_list = self.temp_item.p_list
self.status = ''
elif self.status == "scale":
if self.mousePressDetect(event) == 1:
self.start_point = [x, y]
else:
self.temp_p_list = self.temp_item.p_list
elif self.status == 'clip_CS' or self.status == 'clip_LB':
if self.mousePressDetect(event) == 1:
if self.temp_item1 != None:
self.scene().removeItem(self.temp_item1)
self.temp_item1 = MyItem(self.temp_id, "polygon",
[[x, y], [x, y]], 'DDA',
QColor(0, 0, 255))
self.scene().addItem(self.temp_item1)
self.start_point = [x, y]
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, True)
self.drawing = True
else:
self.temp_p_list = self.temp_item.p_list
self.scene().removeItem(self.temp_item1)
self.main_window.list_widget.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.main_window.menubar.setAttribute(
Qt.WA_TransparentForMouseEvents, False)
self.drawing = False
if (self.temp_p_list[0]
== self.temp_p_list[1]) and (self.temp_p_list[1]
== [0, 0]):
self.delete_item()
#print("Pos",self.temp_p_list)
elif self.status == 'paste':
self.temp_item = MyItem(self.temp_id, self.copy_board.item_type,
self.copy_board.p_list,
self.copy_board.algorithm, self.col)
self.temp_item.finish_draw = True
centerx = 0
centery = 0
for i in self.copy_board.p_list:
centerx += i[0]
centery += i[1]
centerx = centerx / len(self.copy_board.p_list)
centery = centery / len(self.copy_board.p_list)
self.start_point = [x, y]
self.temp_item.p_list = alg.translate(self.copy_board.p_list,
x - centerx, y - centery)
self.scene().addItem(self.temp_item)
self.item_dict[self.temp_id] = self.temp_item
cglog.log("paste success " + " get item {}".format(self.temp_id))
self.list_widget.addItem(str(self.temp_id))
self.finish_draw()
elif self.status == 'free':
self.temp_item = MyItem(self.temp_id, self.status, [[x, y]],
self.temp_algorithm, self.col)
self.scene().addItem(self.temp_item)
else:
if self.status == '':
pass
#cglog.log("Hit Empty State in Mousepressed ")
else:
cglog.log("Hit unknown State in Mousepressed " + self.status)
self.updateScene([self.sceneRect()])
super().mousePressEvent(event)
elif line[0] == 'drawEllipse':
item_id = line[1]
x0 = int(line[2])
y0 = height - 1 - int(line[3])
x1 = int(line[4])
y1 = height - 1 - int(line[5])
item_dict[item_id] = [
'ellipse', [[x0, y0], [x1, y1]], 0,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = -int(line[3])
p_list = item_dict[item_id][1].copy()
item_dict[item_id][1] = alg.translate(p_list, dx, dy)
elif line[0] == 'rotate':
item_id = line[1]
xc = int(line[2])
yc = height - 1 - int(line[3])
angle = int(line[4])
p_list = item_dict[item_id][1].copy()
item_dict[item_id][1] = alg.rotate(p_list, xc, yc, angle)
elif line[0] == 'scale':
item_id = line[1]
xc = int(line[2])
yc = height - 1 - int(line[3])
s = float(line[4])
p_list = item_dict[item_id][1].copy()
item_dict[item_id][1] = alg.scale(p_list, xc, yc, s)
elif line[0] == 'clip':
def translate(self, dx, dy):
self.p_list = alg.translate(self.p_list, dx, dy)
point.append([int(line[i]), int(line[i + 1])])
i += 2
algorithm = line[-1]
item_dict[item_id] = [
'curve', point, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
x0 = int(line[2])
y0 = int(line[3])
graph_type = item_dict[item_id][0]
control_point = item_dict[item_id][1]
algorithm = item_dict[item_id][2]
color = item_dict[item_id][3]
new_control_point = alg.translate(control_point, x0, y0)
item_dict[item_id] = [
graph_type, new_control_point, algorithm, color
]
elif line[0] == 'rotate':
item_id = line[1]
x0 = int(line[2])
y0 = int(line[3])
r = int(line[4])
r = 360 - r
graph_type = item_dict[item_id][0]
control_point = item_dict[item_id][1]
algorithm = item_dict[item_id][2]
color = item_dict[item_id][3]
new_control_point = alg.rotate(control_point, x0, y0, r)
item_dict[item_id] = [
pixels = []
for i in range(0, coor_num):
x = int(line[2 + 2 * i])
y = int(line[3 + 2 * i])
pixels.append([x, y])
algorithm = line[-1]
item_dict[item_id] = [
'curve', pixels, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
if item_id in item_dict:
new_p_list = alg.translate(item_dict[item_id][1], dx, dy)
item_dict[item_id][1] = new_p_list
elif line[0] == 'rotate':
item_id = line[1]
xr = int(line[2])
yr = int(line[3])
theta = int(line[4])
if item_id in item_dict:
# can't rotate ellipse
if item_dict[item_id][0] != 'ellipse':
new_p_list = alg.rotate(item_dict[item_id][1], xr, yr,
theta)
item_dict[item_id][1] = new_p_list
elif line[0] == 'scale':
item_id = line[1]
xs = int(line[2])
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'translate':
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
self.temp_item.p_list = alg.translate(self.temp_plist,
x - self.translateOrigin[0],
y - self.translateOrigin[1])
elif self.status == 'scale':
if self.scalePoint != [-1, -1]:
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
a1 = self.corePoint[0] - self.scalePoint[0]
b1 = self.corePoint[1] - self.scalePoint[1]
a2 = self.corePoint[0] - self.projectPointToLine(
self.corePoint, self.scalePoint, [x, y])[0]
b2 = self.corePoint[1] - self.projectPointToLine(
self.corePoint, self.scalePoint, [x, y])[1]
if a1 == 0:
pivotLength = b1
nowLength = b2
elif b1 == 0:
pivotLength = a1
nowLength = a2
else:
if abs(a1) > abs(b1):
pivotLength = a1
nowLength = a2
else:
pivotLength = b1
nowLength = b2
s = nowLength / pivotLength
self.temp_item.p_list = alg.scale(self.temp_plist,
self.scalePoint[0],
self.scalePoint[1], 1 - s)
self.helperLines_item.p_list = []
for point in self.temp_item.p_list:
self.helperLines_item.p_list.append(
[point, self.scalePoint])
elif self.status == 'rotate':
if self.rotatePoint != [-1, -1]:
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
x1, y1 = self.corePoint[0], self.corePoint[1]
x2, y2 = self.rotatePoint[0] - x1, self.rotatePoint[1] - y1
x3, y3 = x - x1, y - y1
flip = False
if x2 == 0:
if x3 < 0:
flip = True
elif x2 < 0:
k = -y2 / x2
if -y3 < k * x3:
flip = True
elif x2 > 0:
k = -y2 / x2
if -y3 > k * x3:
flip = True
a = math.sqrt(pow(x3 - x2, 2) + pow(y3 - y2, 2))
b = math.sqrt(x2 * x2 + y2 * y2)
c = math.sqrt(x3 * x3 + y3 * y3)
cosA = (b * b + c * c - a * a) / (2 * b * c)
r = int(math.acos(cosA) * 180 / math.pi)
if flip:
r = 360 - r
self.temp_item.p_list = alg.rotate(self.temp_plist,
self.corePoint[0],
self.corePoint[1], r)
# if self.temp_item.item_type == 'polygon' or self.temp_item.item_type == 'curve':
#
self.helperLines_item.p_list = []
for point in self.temp_item.p_list:
self.helperLines_item.p_list.append(
[point, self.rotatePoint])
elif self.status == 'clip':
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
self.clipPoint2 = [x, y]
if self.temp_item:
self.helperPoints_item.p_list = self.temp_item.p_list[:]
self.checkHelper()
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
pos = self.mapToScene(event.localPos().toPoint())
x = int(pos.x())
y = int(pos.y())
if self.status == 'line':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'ellipse':
self.temp_item.p_list[1] = [x, y]
elif self.status == 'polygon':
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'curve':
self.temp_item.p_list[-1] = [x, y]
elif self.status == 'translate':
if self.selected_id != '':
dx = x - int(self.origin_pos.x())
dy = y - int(self.origin_pos.y())
self.temp_item.p_list = alg.translate(self.origin_p_list, dx,
dy)
elif self.status == 'rotate':
if self.selected_id != '' and self.trans_center is not None and self.origin_pos is not None:
x_origin, y_origin = int(self.origin_pos.x() -
self.trans_center.x()), int(
self.origin_pos.y() -
self.trans_center.y())
len_origin = math.sqrt(x_origin**2 + y_origin**2)
x_now, y_now = x - int(self.trans_center.x()), y - int(
self.trans_center.y())
len_now = math.sqrt(x_now**2 + y_now**2)
if len_origin != 0 and len_now != 0:
sin_origin = y_origin / len_origin
cos_origin = x_origin / len_origin
sin_now = y_now / len_now
cos_now = x_now / len_now
delta_sin = sin_now * cos_origin - cos_now * sin_origin
delta_cos = cos_now * cos_origin + sin_now * sin_origin
if delta_cos >= 0:
r = math.asin(delta_sin)
else:
r = math.pi - math.asin(delta_sin)
self.temp_item.p_list = alg.rotate(
self.origin_p_list, int(self.trans_center.x()),
int(self.trans_center.y()), r, False)
elif self.status == 'scale':
if self.selected_id != '' and self.trans_center is not None and self.origin_pos is not None:
x_last, y_last = int(self.origin_pos.x() -
self.trans_center.x()), int(
self.origin_pos.y() -
self.trans_center.y())
len_last = math.sqrt(x_last**2 + y_last**2)
if len_last != 0:
x_now, y_now = x - int(self.trans_center.x()), y - int(
self.trans_center.y())
len_now = math.sqrt(x_now**2 + y_now**2)
self.temp_item.p_list = alg.scale(
self.origin_p_list, int(self.trans_center.x()),
int(self.trans_center.y()), len_now / len_last)
elif self.status == 'clip':
if self.selected_id != '' and self.origin_pos is not None and self.temp_item.item_type == 'line':
x_min = min(int(self.origin_pos.x()), x)
x_max = max(int(self.origin_pos.x()), x)
y_min = min(int(self.origin_pos.y()), y)
y_max = max(int(self.origin_pos.y()), y)
'''
self.temp_item.p_list = alg.clip(self.origin_p_list, x_min, y_min, x_max, y_max, self.temp_algorithm)
print(self.temp_item.p_list)
'''
if self.border is None:
self.border = QGraphicsRectItem(x_min - 1, y_min - 1,
x_max - x_min + 2,
y_max - y_min + 2)
self.scene().addItem(self.border)
self.border.setPen(QColor(0, 255, 255))
else:
self.border.setRect(x_min - 1, y_min - 1,
x_max - x_min + 2, y_max - y_min + 2)
elif self.status == 'freedom':
self.temp_item.p_list.append([x, y])
self.updateScene([self.sceneRect()])
super().mouseMoveEvent(event)
p_list = [(int(line[i]), int(line[i + 1]))
for i in range(2,
len(line) - 1, 2)]
algorithm = line[-1]
item_dict[item_id] = [
'curve', p_list, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
item_type, p_list, algorithm, color = item_dict[item_id]
item_dict[item_id] = [
item_type,
alg.translate(p_list, dx, dy), algorithm, color
]
elif line[0] == 'rotate':
item_id = line[1]
x = int(line[2])
y = int(line[3])
r = int(line[4])
item_type, p_list, algorithm, color = item_dict[item_id]
item_dict[item_id] = [
item_type,
alg.rotate(p_list, x, y, -r), algorithm, color
]
elif line[0] == 'scale':
item_id = line[1]
x = int(line[2])
y = int(line[3])
item_id = line[1]
p_list = []
for i in range(0, (len(line) - 3) // 2):
p_list.append(
[int(line[2 + i * 2]),
int(line[2 + i * 2 + 1])])
algorithm = line[len(line) - 1]
item_dict[item_id] = [
'curve', p_list, algorithm,
np.array(pen_color)
]
elif line[0] == 'translate':
item_id = line[1]
dx = int(line[2])
dy = int(line[3])
item_dict[item_id][1] = alg.translate(item_dict[item_id][1],
dx, dy)
elif line[0] == 'rotate':
item_id = line[1]
x = int(line[2])
y = int(line[3])
r = int(line[4])
item_dict[item_id][1] = alg.rotate(item_dict[item_id][1], x, y,
r)
elif line[0] == 'scale':
item_id = line[1]
x = int(line[2])
y = int(line[3])
s = float(line[4])
item_dict[item_id][1] = alg.scale(item_dict[item_id][1], x, y,
s)
elif line[0] == 'clip':
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, \
widget: Optional[QWidget] = ...) -> None:
def angle(v1, v2):
"""计算v2相对于v1的顺时针角度
v1 = [[x0,y0],[x1,y1]], v2同理
"""
dx1 = v1[1][0] - v1[0][0]
dy1 = v1[1][1] - v1[0][1]
dx2 = v2[1][0] - v2[0][0]
dy2 = v2[1][1] - v2[0][1]
angle1 = math.atan2(dy1, dx1)
angle1 = int(angle1 * 180/math.pi)
angle2 = math.atan2(dy2, dx2)
angle2 = int(angle2 * 180/math.pi)
ret = angle1 - angle2
return ret
def thick_draw_point(painter, poi):
"""加粗绘制一个点,用于裁剪线段时高亮选中部分"""
painter.drawPoint(*[poi[0]+1,poi[1]+1])
painter.drawPoint(*[poi[0]+1,poi[1]-1])
painter.drawPoint(*[poi[0]-1,poi[1]+1])
painter.drawPoint(*[poi[0]-1,poi[1]-1])
return
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
def paint_dotted_line(painter, p_list):
pixels = alg.draw_dotted_line(p_list)
for p in pixels:
painter.drawPoint(*p)
if self.p_list == [] or self.item_type == 'delete':
# be deleted
return
# change p_list accoring to edit_type
new_p_list = self.p_list
if self.edit_type == 'translate':
# 控制点
painter.setPen(QColor(255,0,255))
paint_small_cycle(painter, [self.poi, self.poi1])
paint_dotted_line(painter, [self.poi, self.poi1])
new_p_list = alg.translate(self.p_list, self.poi1[0]-self.poi[0], \
self.poi1[1]-self.poi[1])
if self.edit_over == 1:
# finish
self.edit_finish(new_p_list)
elif self.edit_type == 'rotate':
if self.item_type == 'ellipse':
# g_window.statusBar().clearMessage()
print("Can't rotate ellipse.")
self.edit_finish(self.p_list)
else:
painter.setPen(QColor(255,0,255))
if self.param_cnt==1:
paint_small_cycle(painter, [self.center])
elif self.param_cnt == 2:
paint_small_cycle(painter, [self.center, self.poi, self.poi1])
paint_dotted_line(painter, [self.center, self.poi])
paint_dotted_line(painter, [self.center, self.poi1])
# center and poi, poi1 all gotten
theta = angle([self.center, self.poi], [self.center, self.poi1])
new_p_list = alg.rotate(self.p_list, \
self.center[0], self.center[1], theta)
if self.edit_over == 1:
# clear
self.edit_finish(new_p_list)
elif self.edit_type == 'scale':
painter.setPen(QColor(255,0,255))
if self.param_cnt == 1:
paint_small_cycle(painter, [self.center])
if self.param_cnt == 2:
paint_small_cycle(painter, [self.center, self.poi, self.poi1])
paint_dotted_line(painter, [self.center, self.poi])
paint_dotted_line(painter, [self.center, self.poi1])
# 缩放倍数, 根据dx的比值确定
if self.poi[0]-self.center[0] == 0:
s = 1
else :
s = (self.poi1[0]-self.center[0])/(self.poi[0]-self.center[0])
new_p_list = alg.scale(self.p_list, \
self.center[0], self.center[1], s)
if self.edit_over == 1:
self.edit_finish(new_p_list)
elif self.edit_type == 'clip':
if self.edit_over == 0:
# draw the clip window
painter.setPen(QColor(0,255,0))
painter.drawRect( self.regionRect([self.poi,self.poi1]) )
tmp_p_list = alg.clip(self.p_list, self.poi[0], self.poi[1],\
self.poi1[0], self.poi1[1], self.edit_algorithm)
if tmp_p_list != []:
# highlight the line in clip window
tmp_pixels = self.get_draw_pixels(tmp_p_list,self.algorithm)
painter.setPen(QColor(0, 255, 0))
for p in tmp_pixels:
thick_draw_point(painter, p)
elif self.edit_over == 1:
# 得到裁剪后的端点
new_p_list = alg.clip(self.p_list, self.poi[0], self.poi[1],\
self.poi1[0], self.poi1[1], self.edit_algorithm)
self.edit_finish(new_p_list)
if self.p_list == []:
# 线段被裁剪没了
self.item_type = 'delete'
self.pixels = []
g_canvas.clear_selection()
g_list_widget.takeItem(g_list_widget.currentRow())
del g_canvas.item_dict[self.id]
#下面这句加了后,画布大小改变后再删除图元会崩溃
# g_canvas.scene().removeItem(self)
return
# 填充
if self.isPadding:
painter.setPen(self.paddingColor)
polygon_padding(painter, self)
item_pixels = []
if new_p_list != []:
if self.id == g_canvas.cur_id:
item_pixels = self.get_draw_pixels(new_p_list, self.algorithm)
self.pixels = item_pixels
else:
item_pixels = self.pixels
else :
print("Undefined Behavior: new_p_list shouldn't be []")
# 线段被裁剪没了的话不该到这一步
return
# draw
painter.setPen(self.penColor)
for p in item_pixels:
painter.drawPoint(*p)
# draw bound
if self.selected:
painter.setPen(QColor(255, 0, 0))
painter.drawRect(self.regionRect(new_p_list))
pass
