def draw_ackerman_model(image, center, object, mtp_ratio, pursuit_point=None):
corners = object.get_axel_corners()
corners = center + np.array(corners) * mtp_ratio
corners = corners.reshape((-1, 1, 2))
# Drawing axel frame
cv2.polylines(image, [corners.astype(np.int32)], True, (255, 50, 255), 1)
front_left_tyre = center + np.array(object.front_left_tyre) * mtp_ratio
front_right_tyre = center + np.array(object.front_right_tyre) * mtp_ratio
rear_left_tyre = center + np.array(object.rear_left_tyre) * mtp_ratio
rear_right_tyre = center + np.array(object.rear_right_tyre) * mtp_ratio
cv2.line(image, tuple(front_left_tyre[0].astype(np.int32)),
tuple(front_left_tyre[1].astype(np.int32)), (0, 0, 255), 3,
cv2.LINE_AA)
cv2.line(image, tuple(front_right_tyre[0].astype(np.int32)),
tuple(front_right_tyre[1].astype(np.int32)), (0, 0, 255), 3,
cv2.LINE_AA)
cv2.line(image, tuple(rear_left_tyre[0].astype(np.int32)),
tuple(rear_left_tyre[1].astype(np.int32)), (255, 0, 0), 3,
cv2.LINE_AA)
cv2.line(image, tuple(rear_right_tyre[0].astype(np.int32)),
tuple(rear_right_tyre[1].astype(np.int32)), (255, 0, 0), 3,
cv2.LINE_AA)
if not pursuit_point is None:
cv2.circle(
image,
tuple(center + (pursuit_point * mtp_ratio).astype(np.int32)), 3,
(0, 100, 255), -1)
def callback(self, ros_data):
'''Callback function of subscribed topic.
Here images get converted and features detected'''
if VERBOSE:
print('received image of type: "%s"' % ros_data.format)
np_arr = np.fromstring(ros_data.data, np.uint8)
# Direct conversion to CV2
frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR) # OpenCV >= 3.0:
# Get frame dimensions
frame_height = frame.shape[0]
frame_width = frame.shape[1]
frame_channels = frame.shape[2]
# Image processing
res = self.blue_filtering(frame)
# Detect centrode
cX, cY = self.detect_centrode(res)
# Write the point (cX,xY) on "res" image
cv2.circle(res, (int(cX), int(cY)), 5, (255, 0, 0), -1)
# Normalizing w.r.t the center
cX = int(cX - frame_width / 2)
cY = int(cY - frame_height / 2)
self.greenX_pub.publish(cX)
# Print the center of mass coordinates w.r.t the center of image and diplay it
if VERBOSE:
print(cX, cY)
cmd = self.extraction(cX)
print(cmd)
# Display the result
if DISPLAY:
cv2.imshow('frame', frame)
cv2.imshow("res_center", res)
cv2.waitKey(2)
def locate(target, want, show=0, msg=0):
loc_pos = []
want, treshold, c_name = want[0], want[1], want[2]
result = cv2.matchTemplate(target, want, cv2.TM_CCOEFF_NORMED)
location = numpy.where(result >= treshold)
if msg: # 显示正式寻找目标名称，调试时开启
print(c_name, 'searching... ')
h, w = want.shape[:-1] # want.shape[:-1]
n, ex, ey = 1, 0, 0
for pt in zip(*location[::-1]): # 其实这里经常是空的
x, y = pt[0]+int(w/2), pt[1]+int(h/2)
if (x-ex)+(y-ey) < 15: # 去掉邻近重复的点
continue
ex, ey = x, y
cv2.circle(target, (x, y), 10, (0, 0, 255), 3)
if msg:
print(c_name, 'we find it !!! ,at', x, y)
x, y = int(x), int(y)
loc_pos.append([x, y])
if show: # 在图上显示寻找的结果，调试时开启
cv2.imshow('we get', target)
cv2.waitKey(0)
cv2.destroyAllWindows()
return loc_pos
def facial_features_extraction():
photo = 'sample.jpg'
faceslist = []
facial_landmarks = []
image = Image.open(open(photo, 'rb'))
iwidth, iheight = image.size
res = detect_faces_from_localfile(photo)
faces = res["FaceDetails"]
for face in faces:
faceslist.append(face)
facial_landmarks.append(face["Landmarks"])
while True:
image = cv2.imread(photo)
for face in faceslist:
for lan in face["Landmarks"]:
cv2.circle(
image,
(round(lan["X"] * iwidth), round(lan["Y"] * iheight)), 5,
(0, 0, 255), -1)
left = iwidth * face["BoundingBox"]['Left']
top = iheight * face["BoundingBox"]['Top']
width = iwidth * face["BoundingBox"]['Width']
height = iheight * face["BoundingBox"]['Height']
cv2.rectangle(image, (round(left), round(top)),
(round(left + width), round(top + height)),
(0, 255, 0), 2)
image = resizeimage(image)
cv2.imshow("image", image)
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
def show_correspondence_circles(imgA, imgB, X1, Y1, X2, Y2):
"""
Visualizes corresponding points between two images by plotting circles at
each correspondence location. Corresponding points will have the same random color.
Args:
- imgA: A numpy array of shape (M,N,3)
- imgB: A numpy array of shape (D,E,3)
- x1: A numpy array of shape (k,) containing x-locations of keypoints in imgA
- y1: A numpy array of shape (k,) containing y-locations of keypoints in imgA
- x2: A numpy array of shape (j,) containing x-locations of keypoints in imgB
- y2: A numpy array of shape (j,) containing y-locations of keypoints in imgB
Returns:
- newImg: A numpy array of shape (max(M,D), N+E, 3)
"""
newImg = hstack_images(imgA, imgB)
shiftX = imgA.shape[1]
X1 = X1.astype(np.int)
Y1 = Y1.astype(np.int)
X2 = X2.astype(np.int)
Y2 = Y2.astype(np.int)
for x1, y1, x2, y2 in zip(X1, Y1, X2, Y2):
cur_color = np.random.rand(3)
green = (0, 1, 0)
newImg = cv2.circle(newImg, (x1, y1), 10, cur_color, -1, cv2.LINE_AA)
newImg = cv2.circle(newImg, (x1, y1), 10, green, 2, cv2.LINE_AA)
newImg = cv2.circle(newImg, (x2 + shiftX, y2), 10, cur_color, -1,
cv2.LINE_AA)
newImg = cv2.circle(newImg, (x2 + shiftX, y2), 10, green, 2,
cv2.LINE_AA)
return newImg
def keyDetection(orig_img,
num_labels,
labels,
stats,
centroids,
min_key_area=100,
display_result=False):
final_labels = []
output_img = orig_img.copy()
# Loop through the detected connected components
for i in range(1, num_labels):
[x, y, w, h, area] = getConnectedComponentRectangle(stats[i, :])
(cX, cY) = centroids[i]
# Consider only connected that have an area greater than min_key_area pixels
if (min_key_area < area < np.inf):
final_labels.append([i, cX])
# Display on original image
if (display_result):
cv2.rectangle(output_img, (x, y), (x + w, y + h), (255, 0, 0),
1)
cv2.circle(output_img, (int(cX), int(cY)), 4, (255, 255, 0),
-1)
#componentMask = (labels == i).astype("uint8") * 255
cv2.imshow("Output", output_img)
cv2.waitKey(0)
key_width = statistics.median(stats[:, cv2.CC_STAT_WIDTH])
cv2.destroyAllWindows()
#Return the centroid of the processed connected components and the median width
return final_labels, key_width
def draw_circle(event, x, y, flags, param):
global point1, img, G_RECT
img2 = img.copy() # 这里必须要拷贝一个新的
if event == cv.EVENT_LBUTTONDOWN: # 获取左上角的坐标
point1 = x, y
print("point1: ", point1)
# 画图的时候是先在img2数据上进行处理，之后再将其显示出来
cv.circle(img2, point1, 10, LINE_COLOR, LINE_WIDTH)
cv.imshow("ori_image", img2)
elif event == cv.EVENT_MOUSEMOVE and (flags & cv.EVENT_FLAG_LBUTTON):
cv.rectangle(img2, point1, (x, y), LINE_COLOR, LINE_WIDTH)
cv.imshow("ori_image", img2)
elif event == cv.EVENT_LBUTTONUP: # 鼠标左键按钮松开的时候画图
point2 = x, y
print("point2", point2)
if point1 != point2:
min_x = min(point1[0], point2[0])
min_y = min(point1[1], point2[1])
width = abs(point1[0] - point2[0])
height = abs(point1[1] - point2[1])
G_RECT = [min_x, min_y, width, height]
print("g_rect: ", G_RECT)
cv.rectangle(img2, point1, point2, LINE_COLOR, LINE_WIDTH)
cv.imshow('ori_image', img2)
def showData(self, data: Data):
""" To show data if this module start standalone """
if data.source_name == self.ME_NAME + '/Skeleton':
person = data.data #Points of skeleton
aux = data.strToJSon(data.aux)
h = int(Misc.hasKey(aux, 'H', self.ME_CONFIG['FRAME_HEIGHT']))
w = int(Misc.hasKey(aux, 'W', self.ME_CONFIG['FRAME_WIDTH']))
rgbImage = np.zeros((h, w, 3), np.uint8)
for idj, join in enumerate(person):
if join[0] != None:
cv2.circle(rgbImage, (join[0], join[1]),
5,
self.colors[idj],
thickness=-1)
elif data.source_name == self.ME_NAME + '/Person':
rgbImage = np.zeros((data.data.shape[0], data.data.shape[1], 3),
dtype=np.uint8)
rgbImage[:, :, 0] = np.where(data.data[:, :] == 1, 255, 0)
rgbImage[:, :, 1] = np.where(data.data[:, :] == 1, 255, 0)
rgbImage[:, :, 2] = np.where(data.data[:, :] == 1, 255, 0)
else:
rgbImage = data.data # For capture the image in RGB color space
# Display the resulting frame
cv2.imshow(data.source_name + '-' + data.source_item,
cv2.cvtColor(rgbImage, cv2.COLOR_BGR2RGB))
if cv2.waitKey(1) & 0xFF == ord('q'):
self.stop()
cv2.destroyAllWindows()
def click_event(event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDOWN:
cv2.circle(img, (x, y), 3, (0, 0, 255), -1)
points.append((x, y))
if len(points) >= 2:
cv2.line(img, points[-1], points[-2], (255, 0, 0), 2)
cv2.imshow('image', img)
def draw_boxes_on_img(image):
""" 在传入的图片上画出边角
返回：画图后的图片，坐标，是否能画图
"""
# 边缘检测
img = image.copy()
try:
binary_img = getCanny(img)
# 找边缘
max_contour, max_area = findMaxContour(binary_img)
# 拟合矩形
boxes = getBoxPoint(max_contour)
# 画矩形
cv2.drawContours(img, max_contour, -1, (0, 255, 0), 9)
# print(boxes)
# [ 369 355]
# [2152 465]
# [2364 2776]
# [ 400 2985]
# 画圆圈
for box in boxes:
cv2.circle(img, tuple(box), 30, (0, 255, 255), 10)
return img, boxes, True
except:
print('无法检测')
boxes = None
return image, boxes, False
def extra_processing(showFrame):
global pipeline
m_table = NetworkTablesInstance.getDefault().getTable("JETSONNANO")
# Get the biggest contor and process.
if pipeline.filter_contours_output:
m_MAXCnt = sorted(pipeline.filter_contours_output,
key=cv2.contourArea)[0]
# Find the bounding boxes of the contour to get x, y, width, and height.
x, y, w, h = cv2.boundingRect(m_MAXCnt)
# Dilver data to roborio by NetworkTable.
m_table.putBoolean("IsHaveTarget", True)
m_table.putNumber("SpinError", (x + w / 2) - showFrame.shape[1]/2)
# Show the image when you need it.
cv2.drawContours(showFrame, m_MAXCnt, -1, 255, 3)
cv2.circle(
showFrame, (int(x + w / 2), int(y + h / 2)), 3, (0, 0, 255), -1)
print("Target Get!!! ", "X:", int(x + w / 2), "Y:",
int(y + h / 2), "Error:", (x + w / 2) - showFrame.shape[1]/2)
else:
m_table.putBoolean("IsHaveTarget", False)
print("Target Lose QvQ")
def main():
image_address = str(input('Enter the image name: '))
image_address = "pool_Images/" + image_address
print(image_address)
ball_coord, cue_coord, stick_coord = detection.detect_coordinates2(image_address)
#print(cue_coord, ball_coord, stick_coord)
if len(cue_coord) == 0 or len(stick_coord) == 0:
print("No point detected")
return
cue_point = Point(cue_coord[0], cue_coord[1])
stick_point = Point(stick_coord[0], stick_coord[1])
path_of_white_ball(cue_point, stick_coord, cue_coord[2])
#path_of_white_ball(p1, p2, RADIUS)
future_point, collision_ball_info = during_collision(cue_point, cue_coord[2],stick_point,ball_coord)
if future_point == cue_point:
print("No collision")
return
else:
frame = cv.imread(image_address, 1)
cv.circle(frame, (int(collision_ball_info[0]), int(collision_ball_info[1])), 2*int(collision_ball_info[2]), (0, 255, 255), 2)
cv.circle(frame, (int(future_point.x), int(future_point.y)), int(cue_coord[2]), (255, 255, 255), -1)
temp_point = Point(collision_ball_info[0],collision_ball_info[1])
colored_future_point = intersection(Ray(future_point,temp_point),Circle(temp_point,collision_ball_info[2]*5))
cv.line(frame, (cue_point.x, cue_point.y), (future_point.x, future_point.y), (255, 255, 255), thickness=2)
cv.line(frame, ((int)(collision_ball_info[0]), (int)(collision_ball_info[1])), ((int)(colored_future_point[0].x), (int)(colored_future_point[0].y)), (0, 255, 0), thickness=2)
while 1:
cv.namedWindow('Image',cv.WND_PROP_FULLSCREEN)
cv.imshow('Image', frame)
if cv.waitKey(1) & 0xFF == 27:
break
cv.destroyAllWindows()
def on_mouse(event, x, y, flags, img):
global point1, point2
img2 = img.copy()
if event == cv2.EVENT_LBUTTONDOWN: # 左键点击
point1 = (x, y)
cv2.circle(img2, point1, 10, (0, 255, 0), 5)
cv2.imshow('image', img2)
# 按住左键拖曳
elif event == cv2.EVENT_MOUSEMOVE and (flags & cv2.EVENT_FLAG_LBUTTON):
cv2.rectangle(img2, point1, (x, y), (255, 0, 0), 5)
cv2.imshow('image', img2)
elif event == cv2.EVENT_LBUTTONUP: # 左键释放
point2 = (x, y)
cv2.rectangle(img2, point1, point2, (0, 0, 255), 5)
cv2.imshow('image', img2)
min_x = min(point1[0], point2[0])
min_y = min(point1[1], point2[1])
width = abs(point1[0] - point2[0])
height = abs(point1[1] - point2[1])
cut_img = img[min_y:min_y+height, min_x:min_x+width]
# cv2.imwrite('500.jpg', cut_img)
# 显示RGB三个通道的图像
# 方法一：显示在一张图上
# 按R、G、B三个通道分别计算颜色直方图
b_hist = cv2.calcHist([cut_img], [0], None, [256], [0, 256])
g_hist = cv2.calcHist([cut_img], [1], None, [256], [0, 256])
r_hist = cv2.calcHist([cut_img], [2], None, [256], [0, 256])
# 显示3个通道的颜色直方图
plt.plot(b_hist, label='B', color='blue')
plt.plot(g_hist, label='G', color='green')
plt.plot(r_hist, label='R', color='red')
plt.legend(loc='best')
plt.xlim([0, 256])
plt.show()
def findend():
global endpoint
hsv_image = cv2.cvtColor(img_maze, cv2.COLOR_BGR2HSV)
# define range of red color in HSV
lower_red = np.array([0,100,100])
upper_red = np.array([135,255,255])
# Threshold the HSV image to get only blue colors
mask = cv2.inRange(hsv_image, lower_red, upper_red)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(hsv_image,hsv_image, mask= mask)
cimg=res
res=cv2.cvtColor(res, cv2.COLOR_RGB2GRAY)
circles = cv2.HoughCircles(res,cv2.HOUGH_GRADIENT,1,30,param1=50,param2=10,minRadius=0,maxRadius=0)
#circles = np.uint16(np.around(circles))
for i in circles[0,:]:
# draw the outer circle
cv2.circle(cimg,(i[0],i[1]),i[2],(255,0,0),2)
# draw the center of the circle
cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
endpoint = (i[0],i[1])
def calibrationFunction(event, x, y, flags, params):
global unitDistance
pointsList = params[0]
if (event == cv2.EVENT_LBUTTONDOWN
and len(pointsList) < 2): #Left Click and <2points exist
#Draw Point
cv2.circle(img, (x, y), 2, (0, 0, 255), cv2.FILLED)
#Add to points list
pointsList.append((x, y))
print("Point drawn at:" + str(x) + "," + str(y))
print(pointsList)
if len(pointsList) == 2: #If 2 points drawn
#Draw Line between two points
cv2.line(img, pointsList[0], pointsList[1], (0, 0, 255), 2)
userDistance = input(
"Calibration Line drawn, please enter distance: ")
pixelDistance = math.sqrt(
((pointsList[0][0] - pointsList[1][0])**2 +
(pointsList[0][1] - pointsList[1][1])**2))
unitDistance = float(userDistance) / pixelDistance
print(
"Calibration Complete, please press E to exit calibration mode"
)
def measure_object(image):
gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
print("threshold value:%s" % ret)
cv.imshow("binary image", binary)
dst = cv.cvtColor(binary, cv.COLOR_GRAY2BGR)
contours, hireachy = cv.findContours(binary, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_SIMPLE)
for i, contour in enumerate(contours):
area = cv.contourArea(contour)
x, y, w, h = cv.boundingRect(contour)
mm = cv.moments(contour)
if mm['m00']:
cx = mm['m10'] / mm['m00']
cy = mm['m01'] / mm['m00']
else:
continue
cv.circle(dst, (np.int(cx), np.int(cy)), 3, (0, 0, 255), -1)
cv.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2) #绘制矩形边界
"""
print("area",area)
approxCurve = cv.approxPolyDP(contour,4,True)#多边形逼近
if approxCurve.shape[0] > 6:#边数大于6条的
cv.drawContours(dst,contours,i,(0,0,255),2)
if approxCurve.shape[0] == 4:#矩形
cv.drawContours(dst,contours,i,(0,255,0),2)
if approxCurve.shape[0] == 3:#三角形
cv.drawContours(dst,contours,i,(255,0,0),2)
"""
cv.imshow("image", dst)
cv.imshow("souce", image)
def timeNotes(x,
y,
w,
h,
ith_centroids,
y_offset,
note_height,
keyboard_line,
keyboard_array,
keys_timed_update,
elapsed,
output_img,
font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=0.5,
font_color=(0, 0, 255)):
# x,y,w,h - respective x-coord, y-coord, width and height of a connected component
# ith_centroids - the centroid of a given note (i.e. an x,y pair)
# y_offset - if the keyboard has been offset in the y direction (this allows the detection to stay out of the top/bottom edges)
# note_height - from connectedcomponents
# keyboard_line - the y-coordinate that serves as the threshold/line to calculate press down/up
# keyboard_array - the matrix of keyboard notes/octaves and x-coordinates
# key_timed_update - our array that holds on/off button for each note in our keyboard
# elapsed - time in seconds
# output_img - the screen we want to display to
lag = 2 # number of pixels about the keyboard_line for detection
# Get centroid of detected note
(cX, cY) = ith_centroids
cY = cY + y_offset # We cropped out the first 20 pixels
# Y-coordinate of top and bottom edges of a note (this is truncated by the "size" of the detection area)
dist_to_edge = note_height / 2 #getting the distance from centroid to bottom edge for better detection later on
top_dot = cY - dist_to_edge
bottom_dot = cY + dist_to_edge
# note = Note(cX, cY+dist_to_edge) #creating note object and adding to list
if ((int(bottom_dot) >= int(keyboard_line - lag))
and (int(bottom_dot) <= int(keyboard_line))):
note_played, index = key_pressed(keyboard_array, cX)
keys_timed_update[index].append([elapsed])
# print(note_played)
# print('='*50)
if ((int(top_dot) >= int(keyboard_line - lag))
and (int(top_dot) <= int(keyboard_line))):
note_played, index = key_pressed(keyboard_array, cX)
keys_timed_update[index].append([elapsed])
note_played, _ = key_pressed(keyboard_array, cX)
cv2.line(output_img, (0, int(keyboard_line)), (600, int(keyboard_line)),
(0, 0, 255), 2)
cv2.rectangle(output_img, (x, y), (x + w, y + h), font_color, 1)
cv2.circle(output_img, (int(cX), int(bottom_dot)), 1, (0, 122, 255), 3)
cv2.circle(output_img, (int(cX), int(top_dot)), 1, (0, 122, 255), 3)
cv2.putText(output_img, note_played, (int(cX), int(cY + dist_to_edge)),
font, font_scale, font_color, 1)
return keys_timed_update
def func(ImgNo, defThr=127):
img = cv2.imread(impDef.select_img(ImgNo))
img1 = img.copy()
imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thr = cv2.threshold(imgray, defThr, 255, 0)
contours, _ = cv2.findContours(thr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cnt = contours[0]
# Convex Hull만을 찾기 위해 contours 1개만을 인자로 입력
hull = cv2.convexHull(cnt)
cv2.drawContours(img, [hull], 0, (0, 0, 255), 2)
# Convexity Defects를 찾기위해 2번째 인자로 returnPoints = False를 지정해야 함
# (cnt, returnPoints = False) 인자로 주어진 cnt를 분석하여 Convex Hull을 이루는 모든 좌표를 리턴하는 것이 아니라,
# 원래 Contour와 Convex Hull이 만나는 부부의 Contour 인덱스를 리턴함.
# 즉 별의 꼭지점에 해당하는 5군데를 리턴함.
hull = cv2.convexHull(cnt, returnPoints=False)
defects = cv2.convexityDefects(cnt, hull)
for i in range(defects.shape[0]):
sp, ep, fp, dist = defects[i, 0]
start = tuple(cnt[sp][0])
end = tuple(cnt[ep][0])
farthest = tuple(cnt[fp][0])
cv2.circle(img, farthest, 5, (0, 255, 0), -1)
cv2.imshow('defects', img)
impDef.close_window()
def linie_erkennen(dieser_frame, schwarze_maske, offset):
yoffset = PIXEL_HOEHE - SLICE_HOEHE_FUER_SCHWARZ - offset - 1
roi_line = schwarze_maske[yoffset:yoffset + SLICE_HOEHE_FUER_SCHWARZ,
0:PIXEL_BREITE - 1]
_, konturen, _ = cv2.findContours(roi_line, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cx = 0
cy = yoffset + SLICE_HOEHE_FUER_SCHWARZ / 2
cnt = 0
farbe = GRUEN
linien = []
for kontur in konturen:
x, y, w, h = cv2.boundingRect(kontur)
if w > 50:
if w >= PIXEL_BREITE - 50:
farbe = ROT
ist_kreuzung = True
else:
farbe = GELB
ist_kreuzung = False
cv2.rectangle(dieser_frame, (x, y + yoffset),
(x + w, y + yoffset + h), farbe, 2)
cx = cx + int(x + w / 2)
cnt = cnt + 1
if ist_kreuzung:
linien.append((True, cx - PIXEL_BREITE / 2))
else:
linien.append((False, cx - PIXEL_BREITE / 2))
if cx is 0:
cx = (PIXEL_BREITE - 1) / 2
else:
cx = cx / cnt
cv2.circle(dieser_frame, (int(cx), int(cy)), 5, farbe, -1)
return linien
def PPT(ImgNo, defThr=127):
img = cv2.imread(impDef.select_img(ImgNo))
img2 = img.copy()
imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thr = cv2.threshold(imgray, defThr, 255, 0)
contours, _ = cv2.findContours(thr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cnt = contours[0]
cv2.drawContours(img, [cnt], 0, (0, 255, 0), 2) # contour를 녹색으로 그림
outside = (55, 70)
inside = (140, 150)
# (55, 70)으로 설정된 outside와 (140, 150)으로 설정된 inside에 대해 별보양의 Contour까지 최단거리를 구함
# cv2.pointPolygonTest()함수의 3번째 인자가 True로 설정되면 Contour와 점 사이의 최단거리를 리턴
# cv2.pointPolygonTest()함수의 3번째 인자가 False로 설정되면 주어진 점이 Contour의 외부에 있으면 -1, Contour위에 있으면 0,
# Contour내부에 있으면 1을 리턴
dist1 = cv2.pointPolygonTest(cnt, outside, True)
dist2 = cv2.pointPolygonTest(cnt, inside, True)
print('Contour에서 (%d, %d)까지의 거리 : %.3f' % (outside[0], outside[1], dist1))
print('Contour에서 (%d, %d)까지의 거리 : %.3f' % (inside[0], inside[1], dist2))
cv2.circle(img, outside, 3, (0, 255, 255), -1) # 노란색 점
cv2.circle(img, inside, 3, (255, 0, 255), -1) # 분홍색 점
cv2.imshow('defects', img)
impDef.close_window()
def show_img_with_rect(dst_img,
rect=None,
frame_id=None,
particles=None,
save_dir=None):
tmp_img = np.array(dst_img)
if len(tmp_img.shape) == 2:
tmp_img = cv2.cvtColor(tmp_img, cv2.COLOR_GRAY2BGR)
if rect is not None:
cv2.rectangle(tmp_img, (rect.ly, rect.lx),
(rect.ly + rect.h, rect.lx + rect.w), (255, 0, 0), 1)
if frame_id is not None:
text = 'Frame: {:03d}'.format(frame_id)
cv2.putText(tmp_img, text, (rect.ly, rect.lx), cv2.FONT_HERSHEY_DUPLEX,
1, (0, 0, 255), 2)
if particles is not None:
if not isinstance(particles, list): # Single particle
particles = [particles]
for particle in particles:
cv2.circle(tmp_img, (int(particle.cy), int(particle.cx)), 1,
(0, 255, 0), -1)
# plt.imshow(tmp_img)
# plt.axis('off')
# plt.show()
cv2.imshow('img', tmp_img)
cv2.waitKey(50)
if save_dir is not None:
cv2.imwrite(save_dir / '{:03d}.png'.format(frame_id), tmp_img)
def draw_landmark(img_im, land):
img = copy.deepcopy(img_im)
n = numpy.array(land)
for i in range(len(land)):
cv2.circle(img, (int(n[i][0]), int(n[i][1])), 2, (0, 0, 255), -1)
cv2.imshow('aaa', img)
def getOrientation(self, contour, img):
sz = len(contour)
data_pts = np.empty((sz, 2), dtype=np.float64)
for i in range(data_pts.shape[0]):
data_pts[i, 0] = contour[i, 0, 0]
data_pts[i, 1] = contour[i, 0, 1]
# Perform PCA analysis
mean = np.empty((0))
mean, eigenvectors, eigenvalues = cv2.PCACompute2(data_pts, mean)
# Store the center of the object
cntr = (int(mean[0, 0]), int(mean[0, 1]))
## [pca]
## [visualization]
# Draw the principal components
cv2.circle(img, cntr, 3, (255, 0, 255), 2)
p1 = (cntr[0] + 0.02 * eigenvectors[0, 0] * eigenvalues[0, 0],
cntr[1] + 0.02 * eigenvectors[0, 1] * eigenvalues[0, 0])
p2 = (cntr[0] - 0.02 * eigenvectors[1, 0] * eigenvalues[1, 0],
cntr[1] - 0.02 * eigenvectors[1, 1] * eigenvalues[1, 0])
self.drawAxis(img, cntr, p1, (0, 255, 0), 1)
self.drawAxis(img, cntr, p2, (255, 255, 0), 5)
angle = math.atan2(
eigenvectors[0, 1],
eigenvectors[0, 0]) * 180 / math.pi # orientation in degrees
## [visualization]
return angle
def line_slice(roi_kreuzung, dieser_frame, offset):
"""
Zeichnet auf auf einem Schnit am gegebenen Y-Offset im Kamerabild die gefundenen
Linienstückchen als grüne Rechtecke ein.
Wird die eine Linie zu breit, wird das Rechteck rot eingefärbt.
Das Zentrum aller Linienstückchen in einem Schnitt wird mit einem Punkt markiert.
"""
yoffset = PIXEL_HOEHE - (PIXEL_HOEHE - 200) - 20 - offset
# Horizontalen Streifen an y-Position "offset" herausschneiden
roi_line = dieser_frame[PIXEL_HOEHE - 20 - offset:PIXEL_HOEHE - 1 - offset,
0:PIXEL_BREITE - 1]
# in HSV-Farbschema umwandeln
hsv = cv2.cvtColor(roi_line, cv2.COLOR_BGR2HSV)
# Maske erstellen (Monochromes Bild: Linie weiß, alles andere schwarz)
black_mask = cv2.inRange(hsv, black_lower_limit, black_upper_limit)
# Konturen extrahieren
_, konturen, _ = cv2.findContours(black_mask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cx = 0
cy = yoffset + 5
cnt = 0
farbe = GRUEN
# Liste der X-Positionen der Zentren der gefundenen Linienstücke
ret = []
is_kreuzung = False
for kontur in konturen:
# Rechteck um die Kontur erhalten
x, y, w, h = cv2.boundingRect(kontur)
# zu kleine Konturen wegfiltern
if w > 10:
# zu große Konturen rot einfärben
if w > 150:
farbe = ROT
is_kreuzung = True
# sonst grün einfärben
else:
farbe = GRUEN
# Rechteck um die Kontur zeichnen
cv2.rectangle(roi_kreuzung, (x, y + yoffset),
(x + w, y + yoffset + h), farbe, 2)
# Summe aller x-Positionen der Zentren der gefundenen Rechtecke bilden
cx = cx + int(x + w / 2)
# Anzahl der gefundenen Rechecke mitzählen
cnt = cnt + 1
# Rote Rechtecke: X-Position ist 0 (Mitte des Kamerabildes)
if is_kreuzung:
ret.append(0)
# Grüne Rechtecke: Abweichung von Bildmitte an Liste anfügen
else:
ret.append(cx - PIXEL_BREITE / 2)
# keine Linienstücke gefunden: Durchnitt aller X-Positionen ist Bildmitte
if cx is 0:
cx = (PIXEL_BREITE - 1) / 2
# Linienstückchen gefunden: Durchschnitt aller X-Positionen errechnen
else:
cx = cx / cnt
# Kreis zeichnen an durchschnittlicher X-Position aller gefundenen Linienstückchen
cv2.circle(roi_kreuzung, (int(cx), int(cy)), 5, farbe, -1)
# Ergebnisliste zurückgeben: Liste der Abweichung der Linie von Mitte in Pixel
return ret
def show_correspondence_lines(imgA, imgB, X1, Y1, X2, Y2, line_colors=None):
"""
Visualizes corresponding points between two images by drawing a line segment
between the two images for each (x1,y1) (x2,y2) pair.
Args:
- imgA: A numpy array of shape (M,N,3)
- imgB: A numpy array of shape (D,E,3)
- x1: A numpy array of shape (k,) containing x-locations of keypoints in imgA
- y1: A numpy array of shape (k,) containing y-locations of keypoints in imgA
- x2: A numpy array of shape (j,) containing x-locations of keypoints in imgB
- y2: A numpy array of shape (j,) containing y-locations of keypoints in imgB
- line_colors: A numpy array of shape (N x 3) with colors of correspondence lines (optional)
Returns:
- newImg: A numpy array of shape (max(M,D), N+E, 3)
"""
newImg = hstack_images(imgA, imgB)
shiftX = imgA.shape[1]
X1 = X1.astype(np.int)
Y1 = Y1.astype(np.int)
X2 = X2.astype(np.int)
Y2 = Y2.astype(np.int)
dot_colors = np.random.rand(len(X1), 3)
if line_colors is None:
line_colors = dot_colors
for x1, y1, x2, y2, dot_color, line_color in zip(X1, Y1, X2, Y2,
dot_colors, line_colors):
newImg = cv2.circle(newImg, (x1, y1), 5, dot_color, -1)
newImg = cv2.circle(newImg, (x2 + shiftX, y2), 5, dot_color, -1)
newImg = cv2.line(newImg, (x1, y1), (x2 + shiftX, y2), line_color, 2,
cv2.LINE_AA)
return newImg
def NumberOfFingers(defects, l):
try:
for i in range(defects.shape[0]):
s,e,f,d = defects[i,0]
start = tuple(approx[s][0])
end = tuple(approx[e][0])
far = tuple(approx[f][0])
# Find length of all sides of triangle
a = math.sqrt((end[0] - start[0])**2 + (end[1] - start[1])**2)
b = math.sqrt((far[0] - start[0])**2 + (far[1] - start[1])**2)
c = math.sqrt((end[0] - far[0])**2 + (end[1] - far[1])**2)
s = (a+b+c)/2
ar = math.sqrt(s*(s-a)*(s-b)*(s-c))
d=(2*ar)/a
# Cosine Rule for angle
angle = math.acos((b**2 + c**2 - a**2)/(2*b*c))*(180/math.pi)
# Ignoring angles > 90 and ignore points very close to convex hull
if angle <= 70 and d > 30:
l += 1
cv2.circle(frame, far, 3, [255,0,0], -1)
except AttributeError:
pass
return l
def traffic_lights_masks(self,
traffic_lights: List[carla.Actor]) -> Tuple[Mask]:
red_light_canvas = self.make_empty_mask()
yellow_light_canvas = self.make_empty_mask()
green_light_canvas = self.make_empty_mask()
tls = carla.TrafficLightState
for tl in traffic_lights:
world_pos = tl.get_location()
pos = self.location_to_pixel(world_pos)
radius = int(self.pixels_per_meter * 1.2)
if tl.state == tls.Red:
target_canvas = red_light_canvas
elif tl.state == tls.Yellow:
target_canvas = yellow_light_canvas
elif tl.state == tls.Green:
target_canvas = green_light_canvas
else:
# Unknown or off traffic light
continue
cv.circle(
img=target_canvas,
center=pos,
radius=radius,
color=COLOR_ON,
thickness=cv.FILLED,
)
return red_light_canvas, yellow_light_canvas, green_light_canvas
def visualizeWaypoints(self, waypoints, start_idx=None, show_wp_num=False):
pac_dots = self._img.copy()
pac_dots[:, :] = 0
pac_dots[waypoints[:, 0], waypoints[:, 1]] = 1
num_dilations = 1
kernel = np.ones((2, 2), np.uint8)
pac_dots = cv2.dilate(pac_dots, kernel, iterations=num_dilations)
img = pac_dots + self._safety_img
img_color = img[..., None] * np.array([1, 1, 1])
if start_idx is not None:
try:
for agent in range(len(start_idx)):
color = self._path_colors[(((agent - 1) * -1) + 1) %
self._num_colors]
cv2.circle(img_color,
(waypoints[start_idx[agent],
1], waypoints[start_idx[agent], 0]),
5, color)
except:
print("INVALID STARTING LOCATIONS")
plt.imshow(img_color)
plt.xticks([])
plt.yticks([])
if show_wp_num:
for ii, wp in enumerate(waypoints):
plt.text(wp[1], wp[0], str(ii), color='red', fontsize=8)
# cv2.putText(img_color,str(ii),(wp[1],wp[0]),cv2.FONT_HERSHEY_SIMPLEX,0.25,(255,255,255))
plt.show()
def convexityDetectionImg(self):
try:
img = cv2.imread(self.filename)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(img_gray, 127, 255, 0)
contours, hierarchy = cv2.findContours(thresh, 2, 1)
cnt = contours[0]
hull = cv2.convexHull(cnt, returnPoints=False)
defects = cv2.convexityDefects(cnt, hull)
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = tuple(cnt[s][0])
end = tuple(cnt[e][0])
far = tuple(cnt[f][0])
cv2.line(img, start, end, [0, 255, 0], 2)
cv2.circle(img, far, 5, [0, 0, 255], -1)
cv2.imwrite('img/dist/disbukey.png', img,
[cv2.IMWRITE_JPEG_QUALITY, 100])
cv2.waitKey(0)
cv2.destroyAllWindows()
except:
pass
def linie_erkennen_links(dieser_frame, schwarze_maske):
global cy2
global cx2
global LS
roi_line = schwarze_maske[:PIXEL_HOEHE - 1, :SLICE_BREITE_FUER_SCHWARZ]
_, konturen, _ = cv2.findContours(roi_line, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cy2 = 0
cx2 = SLICE_BREITE_FUER_SCHWARZ_1 / 2
cnt = 0
farbe = GRUEN
linien = []
for kontur in konturen:
x2, y2, w2, h2 = cv2.boundingRect(kontur)
if h2 > 25:
if h2 >= PIXEL_HOEHE - 50:
farbe = ROT
ist_kreuzung = True
else:
farbe = GELB
ist_kreuzung = False
cv2.rectangle(dieser_frame, (x2, y2), (x2 + w2, y2 + h2), farbe, 2)
cy2 = cy2 + int(y2 + h2 / 2)
cnt = cnt + 1
if ist_kreuzung:
linien.append((True, cy2 - PIXEL_HOEHE / 2))
else:
linien.append((False, cy2 - PIXEL_HOEHE / 2))
if cy2 is 0:
LS = False
else:
LS = True
cy2 = cy2 / cnt
cv2.circle(dieser_frame, POINT_2, 5, farbe, -1)
return linien
