def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#界面部分
self.setWindowTitle('FittingLine Tool')
#基础数据部分
self.set_base_data()
#Item 部分设置
self.set_item()
#结果数据部分
self.output_result()
#连接信号与槽
# 数据部分
self.state = State.Idle.value
# self.rect= myRect(myPoint(40,40),10,20,myPoint(1,0))
self.src_img = None
self.line = myLine(myPoint(50, 50), myPoint(150, 150))
self.line_item = FindLineItem(self.line)
self.operator = FittingLineOperator()
self.line_item.setZValue(100)
self.points_item = None
self.file_name = None
self.rects = list()
self.connect_UI()
def on_load_image(self):
file_name, _ = QFileDialog.getOpenFileName(
None, '载入图片',
r"C:\\Users\\Administrator\\Desktop\\CV-Team\\CV-Team\\image",
'Image files(*.jpg *.bmp *.jpeg)')
if file_name:
self.file_name = file_name
if self.file_name is None:
return
qimg = QImage()
qimg.load(self.file_name)
self.view_widget.set_image(qimg) #设置界面图片
if qimg is None:
return
self.view_widget.scene.removeItem(self.rect_item)
if self.points_item is not None:
self.view_widget.scene.removeItem(self.points_item)
self.rect = myRect(myPoint(qimg.width() / 2,
qimg.height() / 2),
qimg.width() / 10,
qimg.height() / 10, myPoint(1, 0))
self.rect_item = RectItem(self.rect)
self.view_widget.add_item(self.rect_item)
cv_img = cv2.imread(self.file_name)
self.operator.calliper.set_img(cv_img) #设置卡尺图片
def mouseMoveEvent(self, event):
if self.in_area == 1:
self.rect = self.rect.resize_by_A(
myPoint(event.pos().x(),
event.pos().y()))
self.prepareGeometryChange()
self.update()
if self.in_area == 2:
self.rect = self.rect.resize_by_B(
myPoint(event.pos().x(),
event.pos().y()))
self.prepareGeometryChange()
self.update()
if self.in_area == 3:
self.rect = self.rect.resize_by_C(
myPoint(event.pos().x(),
event.pos().y()))
self.prepareGeometryChange()
self.update()
if self.in_area == 4:
self.rect = self.rect.resize_by_D(
myPoint(event.pos().x(),
event.pos().y()))
self.prepareGeometryChange()
self.update()
if self.in_area == 5:
self.rect = self.rect.rotate_to(
myPoint(event.pos().x(),
event.pos().y()))
self.prepareGeometryChange()
self.update()
QGraphicsItem.mouseMoveEvent(self, event)
def mouseMoveEvent(self, event):
if self.in_area == 1:
self.line = self.line.resize_by_start(
myPoint(event.pos().x(),
event.pos().y()))
self.generate_rect()
self.prepareGeometryChange()
self.update()
if self.in_area == 2:
self.line = self.line.resize_by_end(
myPoint(event.pos().x(),
event.pos().y()))
self.generate_rect()
self.prepareGeometryChange()
self.update()
if self.in_area == 3:
self.rect_height = self.line.to_point(
myPoint(event.pos().x(),
event.pos().y())) * 2
self.generate_rect()
self.prepareGeometryChange()
self.update()
QGraphicsItem.mouseMoveEvent(self, event)
def find_point(self, diff):
col_num = 0
sort_x = 0
self.points_out.clear()
for i in range(self.AD_count - 1):
col_sum = 0
col_num = 0
for j in range(self.AB_count):
col_sum = diff[i][j] + col_sum
diff_temp = diff[i][j]
if diff_temp != 0:
col_num = col_num + 1
if col_num > 2 * self.AB_count / 3 or col_sum > self.AB_count / 5 * self.threshold:
sort_x = i + self.compensate
break
# else:
# return State.Fail.value
if sort_x == 0:
return State.Fail.value
self.points_out.append(
myPoint(
round(self.A.x + sort_x * self.AD[0][0] / LA.norm(self.AD)),
round(self.A.y + sort_x * self.AD[1][0] / LA.norm(self.AD))))
self.points_out.append(
myPoint(
round(self.B.x + sort_x * self.AD[0][0] / LA.norm(self.AD)),
round(self.B.y + sort_x * self.AD[1][0] / LA.norm(self.AD))))
self.points_out.append(
myPoint(
round(self.points_out[0].x + self.points_out[1].x) / 2,
round(self.points_out[0].y + self.points_out[1].y) / 2))
#print(self.points_out[1].x,self.points_out[1].y)
return State.Success.value
def __init__(self):
self.name = 'calliper'
self.state = State.Idle.value
self.calliper = Calliper()
self.rect = myRect(myPoint(40, 40), 10, 20, myPoint(1, 0))
self.src_img = None
self.input_points = list()
self.output_points = list()
self.output_points_enable = 0
def __init__(self, center, width, height, direction=myPoint(1, 0)):
self.center = center
self.width = width
self.height = height
self.direction = direction.normalized()
vwidth = self.direction * self.width
self.direction_w = myPoint(-self.direction.y, self.direction.x)
vheight = self.direction_w * self.height
self.A = self.center - vwidth / 2 - vheight / 2 #width是x方向 ab,x方向为正方向
self.B = self.center + vwidth / 2 - vheight / 2 #
self.C = self.center + vwidth / 2 + vheight / 2
self.D = self.center - vwidth / 2 + vheight / 2
def generate_rect(self):
rotate_angle = 360 / self.rect_count
self.rects.clear()
for i in range(self.rect_count):
point = myPoint(self.circle.center.x + self.radius,
self.circle.center.y)
rect_center = point.rotate_by(self.circle.center, rotate_angle * i)
self.rects.append(
myRect(rect_center, self.rect_height, self.rect_width,
(rect_center - self.circle.center).normalized()))
def get_rects(self):
scene_rects = list()
for i in range(len(self.rects)):
center_ = self.rects[i].center
scene_center = self.mapToScene(QPointF(center_.x, center_.y))
#print(scene_center)
scene_rects.append(
myRect(myPoint(scene_center.x(),
scene_center.y()), self.rects[i].width,
self.rects[i].height, self.rects[i].direction))
return scene_rects
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#数据部分
self.state = 0
self.rect = myRect(myPoint(40, 40), 10, 20, myPoint(1, 0))
self.src_img = None
self.operator = CalliperOperator()
self.line = None #结果直线
self.rect_item = RectItem(self.rect)
self.rect_item.setZValue(100)
self.points_item = None
self.file_name = None
#界面部分
self.setWindowTitle('Calliper Tool')
group = QGroupBox('this group')
vlay = QVBoxLayout()
vlay.addWidget(group)
self.base_data.setLayout(vlay)
label = QLabel('this is label')
label.setAlignment(Qt.AlignTop | Qt.AlignLeft)
hlay = QHBoxLayout()
input_label = QLabel('input image:')
input_combobox = QComboBox()
input_combobox.addItem('null')
input_combobox.addItem('last')
input_combobox.addItem('next')
hlay.addWidget(input_label)
hlay.addWidget(input_combobox)
hlay.setAlignment(Qt.AlignTop)
vlay1 = QVBoxLayout()
vlay1.addWidget(label)
vlay1.addLayout(hlay)
group.setLayout(vlay1)
def mousePressEvent(self, event):
if self.is_in_area(event.pos(), self.line.start_point, 5):
self.in_area = 1
self.setFlag(QGraphicsItem.ItemIsMovable, False)
elif self.is_in_area(event.pos(), self.line.end_point, 5):
self.in_area = 2
self.setFlag(QGraphicsItem.ItemIsMovable, False)
elif self.rect_height / 2 - 5 < self.line.to_point(
myPoint(event.pos().x(),
event.pos().y())) < self.rect_height / 2 + 5:
self.in_area = 3
self.setFlag(QGraphicsItem.ItemIsMovable, False)
else:
self.in_area = 0
self.setFlag(QGraphicsItem.ItemIsMovable, True)
QGraphicsItem.mousePressEvent(self, event)
def __init__(self,point1,point2,point3):
line12=myLine(point1,point2)
line23=myLine(point2,point3)
if line12.is_parallel_to(line23):
print('3 points in one line')
return
mid_point12 = (point1 + point2) * 0.5
mid_point23 = (point2 + point3) * 0.5
gradient12 = (point2.y - point1.y) / (point2.x - point1.x)
gradient23 = (point3.y - point2.y) / (point3.x - point2.x)
gradient1=-1/gradient12
gradient2=-1/gradient23
denominator=gradient2-gradient1
nominator=mid_point12.y-(gradient1*mid_point12.x)+(gradient2*mid_point23.x)-mid_point23.y
center_x=nominator/denominator
center_y=gradient1*(center_x-mid_point12.x)+mid_point12.y
self.center=myPoint(center_x,center_y)
self.radius=self.center.distance_to(point1)
self.area = self.radius* self.radius * math.pi
self.circumference = 2 * self.radius * math.pi
return myRect((point + self.B) * 0.5, abs(diagonal * cosTheta),
abs(diagonal * sinTheta), self.direction)
def rotate(self, alpha):
new_direction_point = self.direction.rotate_by(self.center, alpha)
new_direction = (new_direction_point - self.center).normalized()
return myRect(self.center, self.width, self.height, new_direction)
def rotate_to(self, point):
new_direction = (point - self.center).normalized()
return myRect(self.center, self.width, self.height, new_direction)
def rotate_by(self, center, alpha):
pass
def scaling(self, other):
pass
if __name__ == '__main__':
center = myPoint(1, 1)
height = 2
width = 2
dir = myPoint(-1, 0)
point2 = myPoint(4, 4)
rect = myRect(center, height, width, dir)
rect1 = rect.resize_by_A(point2)
print('rect1:', rect1.A, rect1.B, rect1.C, rect1.D)
#rect.resize_by_A(point2)
scale = pow(2, (self.view.zoom_slider.value() - 250) * 0.02)
scene_rect = self.scene.sceneRect()
x_ration = self.view.viewport().width() / scene_rect.width()
y_ration = self.view.viewport().height() / scene_rect.height()
if x_ration < y_ration:
y_ration = x_ration
trans.scale(y_ration, y_ration)
self.view.reset_view()
self.view.setTransform(trans)
if __name__ == '__main__':
app = QApplication(sys.argv)
#window=ViewWidget()
#window.show()
point1 = myPoint(40, 50)
width = 50
height = 30
dir = myPoint(3, 4)
rect = myRect(point1, width, height, dir)
circle = myCircle(myPoint(50, 50), 20)
line = myLine(myPoint(50, 50), myPoint(146, 50))
rect_item = RectItem(rect) #RectItem(rect)
circle_item = FindCircleItem(circle)
view_widget = ViewWidget()
img = QImage("../image/cv_team.jpg")
view_widget.set_image(img)
view_widget.add_item(rect_item)
view_widget.add_item(circle_item)
view_widget.show()
view_widget.resize(800, 600)
def on_load_video(self):
pass
def on_add_item(self):
pass
def on_cancel(self):
pass
def on_OK(self):
pass
if __name__ == '__main__':
app = QApplication(sys.argv)
point1 = myPoint(40, 50)
width = 50
height = 30
dir = myPoint(1, 0)
rect = myRect(point1, width, height, dir)
line = myLine(myPoint(50, 50), myPoint(146, 50))
rect_item = RectItem(rect) #RectItem(rect)
operator_base = OperatorBaseWidget()
img = QImage("../image/cv_team.jpg")
operator_base.view_widget.set_image(img)
operator_base.view_widget.add_item(rect_item)
operator_base.show()
operator_base.resize(800, 600)
#window.showMaximized()
app.exec()
if must_be_on_segment:
if dot_product<0:
dot_product=0
if dot_product>self.length:
l=dot_product
along_vector=self.direction*dot_product
return self.start_point+along_vector
def to_point(self,point):
closest_point=self.closest_point(point)
distance=closest_point.distance_to(point)
return distance
def resize_by_start(self,other):
return myLine(other,self.end_point)
def resize_by_end(self,other):
return myLine(self.start_point,other)
if __name__=='__main__':
point1=myPoint(-2,5)
point2=myPoint(2,5)
point3=myPoint(0,0)
point4 = myPoint(2, 8)
line1=myLine(point1,point2)
line2=myLine(point3,point4)
p=line1.resize_by_start(point3)
#print('p:',p.x,p.y)
print(line1.is_perpendicular_to(line2))
def get_rect(self):
center_ = self.rect.center
scene_center = self.mapToScene(QPointF(center_.x, center_.y))
return myRect(myPoint(scene_center.x(), scene_center.y()),
self.rect.width, self.rect.height, self.rect.direction)
print('not enough points')
@staticmethod
def Delete_Points(ok_points, ng_points, delete_count):
X = []
Y = []
for i in range(len(ok_points)):
X.append(ok_points[i].x)
Y.append(ok_points[i].y)
a = numpy.polyfit(X, Y, 1)
print(a)
if __name__ == '__main__':
points = list()
points.append(myPoint(1, 2.5))
points.append(myPoint(2, 3.34))
points.append(myPoint(3, 4.18))
points.append(myPoint(4, 5.87))
points.append(myPoint(5, 6.97))
points.append(myPoint(6, 7.35))
points.append(myPoint(7, 8.17))
points.append(myPoint(8, 9.46))
points.append(myPoint(9, 10.65))
points.append(myPoint(10, 15.98))
points.append(myPoint(11, 11.67))
points.append(myPoint(12, 18))
fit = FittingLine(points)
ok, ng, line = fit.Ransac()
print(len(ok))
print(len(ng))
def hoverMoveEvent(self, event):
if self.is_in_area(event.pos(), self.line.start_point, 5) or self.is_in_area(event.pos(), self.line.end_point, 5) \
or self.rect_height/2-5<self.line.to_point(myPoint(event.pos().x(),event.pos().y()))<self.rect_height/2+5:
self.setCursor(Qt.SizeAllCursor)
else:
self.setCursor(Qt.ArrowCursor)
sort_x = i + self.compensate
break
# else:
# return State.Fail.value
if sort_x == 0:
return State.Fail.value
self.points_out.append(
myPoint(
round(self.A.x + sort_x * self.AD[0][0] / LA.norm(self.AD)),
round(self.A.y + sort_x * self.AD[1][0] / LA.norm(self.AD))))
self.points_out.append(
myPoint(
round(self.B.x + sort_x * self.AD[0][0] / LA.norm(self.AD)),
round(self.B.y + sort_x * self.AD[1][0] / LA.norm(self.AD))))
self.points_out.append(
myPoint(
round(self.points_out[0].x + self.points_out[1].x) / 2,
round(self.points_out[0].y + self.points_out[1].y) / 2))
#print(self.points_out[1].x,self.points_out[1].y)
return State.Success.value
if __name__ == '__main__':
rect_corn = list()
rect_corn.append(myPoint(10, 18))
rect_corn.append(myPoint(30, 18))
rect_corn.append(myPoint(30, 61))
rect_corn.append(myPoint(10, 61))
calliper = Calliper()
#print(calliper.diff)
self.circumference=2*self.radius*math.pi
class my3Circle:
def __init__(self,point1,point2,point3):
line12=myLine(point1,point2)
line23=myLine(point2,point3)
if line12.is_parallel_to(line23):
print('3 points in one line')
return
mid_point12 = (point1 + point2) * 0.5
mid_point23 = (point2 + point3) * 0.5
gradient12 = (point2.y - point1.y) / (point2.x - point1.x)
gradient23 = (point3.y - point2.y) / (point3.x - point2.x)
gradient1=-1/gradient12
gradient2=-1/gradient23
denominator=gradient2-gradient1
nominator=mid_point12.y-(gradient1*mid_point12.x)+(gradient2*mid_point23.x)-mid_point23.y
center_x=nominator/denominator
center_y=gradient1*(center_x-mid_point12.x)+mid_point12.y
self.center=myPoint(center_x,center_y)
self.radius=self.center.distance_to(point1)
self.area = self.radius* self.radius * math.pi
self.circumference = 2 * self.radius * math.pi
if __name__=='__main__':
p1=myPoint(2,0)
p2=myPoint(0,2)
p3=myPoint(-2,0)
circle=my3Circle(p1,p2,p3)
print(circle.center.x,circle.center.y,circle.radius)
