gray = cv2.GaussianBlur(gray, (21, 21), 0)
cv2.imshow("Blur", gray)
state = 0
if frame_1 is None:
frame_1 = gray
continue
delta_frame = cv2.absdiff(gray, frame_1)
cv2.imshow("Delta", delta_frame)
thresh_frame = cv2.threshold(delta_frame, 30, 255, cv2.THRESH_BINARY)[1]
thresh_frame = cv2.dilate(thresh_frame, None, iterations=3)
(cnts, _) = cv2.findContours(thresh_frame.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
for contour in cnts:
if cv2.contourArea(contour) < 2000:
continue
state = 1
x, y, w, h = cv2.boundingRect(contour)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 3)
status.append(state)
if status[-1] == 1 and status[-2] == 0:
times.append(dt.now())
elif status[-1] == 0 and status[-2] == 1:
times.append(dt.now())
cv2.imshow("Initial Frame", frame_1)
cv2.imshow("Threshold", thresh_frame)
# hull = cv2.convexHull(cnt,returnPoints = False)
# defects = cv2.convexityDefects(cnt,hull)
# Note
# Remember we have to pass returnPoints = False while finding convex hull, in order to find convexity defects.
# It returns an array where each row contains these values - [ start point, end point, farthest point, approximate distance to farthest point ]. We can visualize it using an image. We draw a line joining start point and end point, then draw a circle at the farthest point. Remember first three values returned are indices of cnt. So we have to bring those values from cnt.
from cv2 import cv2
import numpy as np
img_star = cv2.imread('resource/star.png')
img = img_star.copy()
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.imshow('img', img)
import numpy as np
from cv2 import cv2
img = cv2.imread('detect_blob.png', 1)
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
thresh_img = cv2.adaptiveThreshold(
gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 115,
1) #guassion threshold with output binary threshold type
#Make sure to binarize image before using contour functions
cv2.imshow("Adaptive Thresh Image", thresh_img)
#Contours
contours, hierarchy = cv2.findContours(thresh_img, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
img2 = img.copy()
index = -1 #if negative all contours are drawn, index of contour to be drawn
thickness = 4
color = (255, 0, 255)
cv2.drawContours(img2, contours, index, color, thickness)
cv2.imshow('Contours', img2)
print("Contours", contours)
cv2.waitKey(0)
cv2.destroyAllWindows()
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
# GAUSSIAN MIXTURE BASED BACKGROUND AND FOREGROUND
fgbg = cv2.bgsegm.createBackgroundSubtractorMOG()
while True:
ret, frame = cap.read()
if ret == True:
# apply fgbg
fgmask = fgbg.apply(frame)
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel)
# find countours
dilation = cv2.dilate(fgmask, kernel_dil, iterations=1)
contours, _ = cv2.findContours(dilation, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# loop and draw box
for con in contours:
x, y, w, h = cv2.boundingRect(con)
# if area countours < 1350 dont draw box
if cv2.contourArea(con) < 1350:
continue
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# draw text on frame
cv2.putText(frame, "Status : {}".format('Movement'), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 3)
cv2.putText(frame, "w={},h={}".format(w, h), (x, y - 10),
cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 255, 0), 2)
def main():
previousFrame = None
previous_x, previous_y = -1, -1
previous_dx, previous_dy = 0, 0
largest_area_x = 0
largest_area_y = 0
direction_log = []
last_movement = time.time() * 1000
while True:
grabbed, frame = camera.read()
frame = imutils.resize(frame, width=500)
frame = cv2.flip(frame, 1)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.1, 3, 0)
gray = cv2.GaussianBlur(gray, (args["blur"], args["blur"]), 0)
# if the first frame is None, initialize it
if previousFrame is None:
previousFrame = gray
continue
# compute the absolute difference between the current frame and
# first frame
frameDelta = cv2.absdiff(previousFrame, gray)
thresh = cv2.threshold(frameDelta, args["threshold"], 255,
cv2.THRESH_BINARY)[1]
# dilate the thresholded image to fill in holes, then find contours
# on thresholded image
thresh = cv2.dilate(thresh, None, iterations=args["dilation"])
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
previousFrame = gray
frameDelta = cv2.cvtColor(frameDelta, cv2.COLOR_GRAY2RGB)
# loop over the contours
largest_area = 0
largest_area_x, largest_area_y = -1, -1
for c in cnts:
# if the contour is too small, ignore it
area = cv2.contourArea(c)
if area < args["min_area"]:
continue
if area > args["max_area"]:
continue
# compute the bounding box for the contour, draw it on the frame,
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.putText(
frame,
str(area),
(x, y),
cv2.FONT_HERSHEY_SIMPLEX,
0.5,
(0, 255, 0),
2,
)
if area > largest_area:
largest_area_x, largest_area_y = x, y
largest_area = area
last_movement = time.time() * 1000
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
cv2.imshow("Frame", frame)
cv2.imshow("Frame Delta", frameDelta)
cv2.imshow("Thresh", thresh)
dx, dy = largest_area_x - previous_x, largest_area_y - previous_y
previous_dx, previous_dy = dx, dy
previous_x, previous_y = largest_area_x, largest_area_y
dx, dy = previous_dx * 0.3 + dx * 0.7, previous_dy * 0.5 + dy * 0.7
# dx, dy = dx/2, dy/2
dx, dy = int(dx), int(dy)
if dx != 0 or dy != 0:
direction = Direction.Null
if abs(dx) > abs(dy):
direction = Direction.Left if dx < 0 else Direction.Right
else:
direction = Direction.Up if dy < 0 else Direction.Down
logging.debug("{}, dx={}, dy={}".format(direction, dx, dy))
direction_log.append(direction)
if time.time() * 1000 - last_movement > args["wait"]:
if len(direction_log) > args["min_sample"]:
direction_result = max(direction_log, key=direction_log.count)
logging.info("Result: {}".format(direction_result))
if direction_result == Direction.Right:
WindowAction.previousDesktop()
if direction_result == Direction.Left:
WindowAction.nextDesktop()
if direction_result == Direction.Up:
WindowAction.maximizeWindow()
if direction_result == Direction.Down:
WindowAction.minimizeWindow()
# for e in Direction:
# logging.info("Result: {} {}x".format(e, direction_log.count(e)))
direction_log.clear()
k = cv2.waitKey(10) & 0xFF
if k == 27:
break
camera.release()
cv2.destroyAllWindows()
paper1 = cv2.cvtColor(org1, cv2.COLOR_BGR2GRAY)
#Canny边缘检测
paper1 = cv2.Canny(paper1, 80, 150)
if show_process:
imshow(paper1)
#膨胀操作
kernel = np.ones((3, 3), np.uint8)
paper1 = cv2.dilate(paper1, kernel, iterations=1)
if show_process:
imshow(paper1)
#轮廓检测
cnts = cv2.findContours(paper1, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[1]
#提取面积最大的轮廓
cnts = sorted(cnts, key=lambda x: cv2.contourArea(x), reverse=True)
#绘制面积最大的轮廓
show = org1.copy()
show = cv2.drawContours(show, cnts, 0, (0, 255, 0), 1)
if show_process:
imshow(show)
cnt = []
#步长设置为周长的0.0001倍，一般来说取epsilon = 0.001倍周长
step = 0.0001 * cv2.arcLength(cnts[0], True)
def gestos_mano():
cap = cv2.VideoCapture(0)
# cap = cv2.VideoCapture(1)
bg = None
# COLORES PARA VISUALIZACIÓN
color_start = (204, 204, 0)
color_end = (204, 0, 204)
color_far = (255, 0, 0)
color_start_far = (204, 204, 0)
color_far_end = (204, 0, 204)
color_start_end = (0, 255, 255)
color_contorno = (0, 255, 0)
color_ymin = (0, 130, 255) # Punto más alto del contorno
# color_angulo = (0,255,255)
# color_d = (0,255,255)
color_fingers = (0, 255, 255)
while True:
ret, frame = cap.read()
if ret == False: break
# Redimensionar la imagen para que tenga un ancho de 640
frame = imutils.resize(frame, width=640)
frame = cv2.flip(frame, 1)
frameAux = frame.copy()
if bg is not None:
# Determinar la región de interés
ROI = frame[50:300, 380:600]
cv2.rectangle(frame, (380 - 2, 50 - 2), (600 + 2, 300 + 2),
color_fingers, 1)
grayROI = cv2.cvtColor(ROI, cv2.COLOR_BGR2GRAY)
# Región de interés del fondo de la imagen
bgROI = bg[50:300, 380:600]
# Determinar la imagen binaria (background vs foreground)
dif = cv2.absdiff(grayROI, bgROI)
_, th = cv2.threshold(dif, 30, 255, cv2.THRESH_BINARY)
th = cv2.medianBlur(th, 7)
# Encontrando los contornos de la imagen binaria
cnts, _ = cv2.findContours(th, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:1]
for cnt in cnts:
# Encontrar el centro del contorno
M = cv2.moments(cnt)
if M["m00"] == 0: M["m00"] = 1
x = int(M["m10"] / M["m00"])
y = int(M["m01"] / M["m00"])
cv2.circle(ROI, tuple([x, y]), 5, (0, 255, 0), -1)
# Punto más alto del contorno
ymin = cnt.min(axis=1)
cv2.circle(ROI, tuple(ymin[0]), 5, color_ymin, -1)
# Contorno encontrado a través de cv2.convexHull
hull1 = cv2.convexHull(cnt)
cv2.drawContours(ROI, [hull1], 0, color_contorno, 2)
# Defectos convexos
hull2 = cv2.convexHull(cnt, returnPoints=False)
defects = cv2.convexityDefects(cnt, hull2)
# Seguimos con la condición si es que existen defectos convexos
if defects is not None:
inicio = [
] # Contenedor en donde se almacenarán los puntos iniciales de los defectos convexos
fin = [
] # Contenedor en donde se almacenarán los puntos finales de los defectos convexos
fingers = 0 # Contador para el número de dedos levantados
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = cnt[s][0]
end = cnt[e][0]
far = cnt[f][0]
# Encontrar el triángulo asociado a cada defecto convexo para determinar ángulo
a = np.linalg.norm(far - end)
b = np.linalg.norm(far - start)
c = np.linalg.norm(start - end)
angulo = np.arccos(
(np.power(a, 2) + np.power(b, 2) - np.power(c, 2))
/ (2 * a * b))
angulo = np.degrees(angulo)
angulo = int(angulo)
# Se descartarán los defectos convexos encontrados de acuerdo a la distnacia
# entre los puntos inicial, final y más alelago, por el ángulo y d
if np.linalg.norm(start - end
) > 20 and angulo < 90 and d > 12000:
# Almacenamos todos los puntos iniciales y finales que han sido
# obtenidos
inicio.append(start)
fin.append(end)
# Visualización de distintos datos obtenidos
# cv2.putText(ROI,'{}'.format(angulo),tuple(far), 1, 1.5,color_angulo,2,cv2.LINE_AA)
# cv2.putText(ROI,'{}'.format(d),tuple(far), 1, 1.1,color_d,1,cv2.LINE_AA)
cv2.circle(ROI, tuple(start), 5, color_start, 2)
cv2.circle(ROI, tuple(end), 5, color_end, 2)
cv2.circle(ROI, tuple(far), 7, color_far, -1)
# cv2.line(ROI,tuple(start),tuple(far),color_start_far,2)
# cv2.line(ROI,tuple(far),tuple(end),color_far_end,2)
# cv2.line(ROI,tuple(start),tuple(end),color_start_end,2)
# Si no se han almacenado puntos de inicio (o fin), puede tratarse de
# 0 dedos levantados o 1 dedo levantado
if len(inicio) == 0:
minY = np.linalg.norm(ymin[0] - [x, y])
if minY >= 110:
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(ymin[0]), 1, 1.7,
(color_fingers), 1, cv2.LINE_AA)
# Si se han almacenado puntos de inicio, se contará el número de dedos levantados
for i in range(len(inicio)):
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(inicio[i]), 1, 1.7, (color_fingers),
1, cv2.LINE_AA)
if i == len(inicio) - 1:
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(fin[i]), 1, 1.7, (color_fingers),
1, cv2.LINE_AA)
# Se visualiza el número de dedos levantados en el rectángulo izquierdo
if fingers == 0:
cv2.putText(frame, 'Auxilio', (390, 45), 1, 2,
(color_fingers), 2, cv2.LINE_AA)
else:
if fingers == 1:
cv2.putText(frame, 'Estoy bien!', (390, 45), 1, 2,
(color_fingers), 2, cv2.LINE_AA)
else:
if fingers == 2:
if angulo > 60:
cv2.putText(frame, 'Tengo hambre',
(390, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
if angulo < 40:
cv2.putText(frame, 'Tengo sueño',
(390, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
if fingers == 3:
cv2.putText(frame, 'Te quiero', (390, 45),
1, 2, (color_fingers), 2,
cv2.LINE_AA)
else:
if fingers == 4:
cv2.putText(frame, 'Gesto desconocido',
(300, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
cv2.putText(frame, 'Hola mundo!',
(300, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
cv2.imshow('th', th)
cv2.imshow('Frame', frame)
k = cv2.waitKey(20)
if k == ord('i'):
bg = cv2.cvtColor(frameAux, cv2.COLOR_BGR2GRAY)
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
def main():
drone = tellopy.Tello()
try:
drone.subscribe(drone.EVENT_FLIGHT_DATA, handler)
drone.connect()
drone.wait_for_connection(30.0)
# 设置连接等待的时间，若超时则抛出错误
drone.takeoff()
time.sleep(3)
container = av.open(drone.get_video_stream())
# skip first 300 frames
frame_skip = 300
while True:
for frame in container.decode(video=0):
if 0 < frame_skip:
frame_skip = frame_skip - 1
continue
start_time = time.time()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, redLower, redUpper)
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
if radius > 10:
cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2)
cv2.circle(frame, center, 5, (0, 0, 255), -1)
pts.appendleft(center)
else:
pts.clear()
length = len(pts)
for i in range(1, length):
if pts[i - 1] is None or pts[i] is None:
continue
thickness = int(np.sqrt(mybuffer / float(i + 1)) * 2.5)
cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), thickness)
cv2.imshow('Frame', frame)
image = cv2.cvtColor(np.array(frame.to_image()), cv2.COLOR_RGB2GRAY)
cv2.imshow('Original', image)
# cv2.imshow('Canny', cv2.Canny(image, 100, 200))
interrupt = cv2.waitKey(10)
if interrupt & 0xFF == ord('q'):
drone.down(30)
time.sleep(3)
drone.land()
time.sleep(3)
print('successfully land!')
break
frame_skip = int((time.time() - start_time)/frame.time_base)
except Exception as ex:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
print(ex)
finally:
drone.quit()
cv2.destroyAllWindows()
# Convert the image into black and white for edge detection
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# For edge detection it is recommended to smoothen the image for better results
blur = cv2.GaussianBlur(gray, (5, 5), 0)
# Fetch the edges of the image
# In this algorithm the edges with intensity greater than maximum threshold are fetched
# Also the values of intensity between minimum and maximum threshold are checked for any connection with edge having maximum intensity
edge = cv2.Canny(blur, 50, 80)
cv2.imshow("Canny Edge", edge)
cv2.waitKey(0)
# Find the contours in image
# Here we used CHAIN_APPROX_SIMPLE to just store the main points of the contour instead of storing the whole contour
contour, hierarchy = cv2.findContours(edge, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
contour = sorted(contour, key=cv2.contourArea, reverse=True)
# Each contour is checked and the contour which is closed and forming an square or rectangle are named as target
for c in contour:
p = cv2.arcLength(c, True)
# Not all contour's are perfect so little approixmation can be used
approx = cv2.approxPolyDP(c, 0.02 * p, True)
if len(approx) == 4:
target = approx
break
approx = mapp(target)
# We define the range of the window (Top left, Top Right, Bottom Right, Bottom Left)
####################################
# Grünerkennung mit Konturen #
####################################
frame_als_hsv = cv2.cvtColor(dieser_frame, cv2.COLOR_BGR2HSV)
# H S V
untere_schwelle = numpy.uint8([40, 80, 20])
obere_schwelle = numpy.uint8([80, 255, 255])
gruen_maske = cv2.inRange(frame_als_hsv, untere_schwelle, obere_schwelle)
BLAU = (255, 0, 0)
ROT = (0, 0, 255)
GRUEN = (0, 255, 0)
# Konturen extrahieren
_, konturen, _ = cv2.findContours(gruen_maske, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# Konturen (Polygone) in blau einzeichnen
# („-1“ bedeutet alle Konturen, „3“, „2“ ist die Dicke der einzuzeichnenden Linie)
cv2.drawContours(dieser_frame, konturen, -1, BLAU, 2)
for kontur in konturen:
# zu kleine Konturen wegfiltern
if cv2.contourArea(kontur) > 4000:
# Dimensionen des Rechtecks um die Kontur extrahieren
x, y, w, h = cv2.boundingRect(kontur)
# Rechteck um die Kontur zeichnen
cv2.rectangle(dieser_frame, (x, y), (x + w, y + h), ROT, 2)
# Kamerabild anzeigen
cv2.imshow("Maze Runner", dieser_frame)
# Motoren ansteuern
img = cv2.imread("fuzzy.png",1)
hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
hsv_split = np.concatenate((hsv[:,:,0],hsv[:,:,1],hsv[:,:,2]),axis=1)
cv2.imshow("HSV Split",hsv_split)
#Dilating Saturation channel and thresholding to get segmentation
kernel=np.ones((3,3),'uint8')
dilate=cv2.dilate(hsv[:,:,1],kernel,iterations=1)
cv2.imshow("S Dilation",dilate)
ret,dilate_thresh = cv2.threshold(dilate,200,255,cv2.THRESH_BINARY)
cv2.imshow("S Dilate Trheshold",dilate_thresh)
#Contours
canvas = np.ones(img.shape,'uint8') * 255
contours,heirarchy = cv2.findContours(dilate_thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
area = cv2.contourArea(c)
perim = cv2.arcLength(c,True)
print("Perimeter: {}, Area: {}".format(perim,area))
if area > 1000:
cv2.drawContours(canvas,[c],-1,(rand.randint(0,255),0,rand.randint(0,255)),-1)
cv2.imshow("FINAL RESULT",canvas)
cv2.waitKey(0)
cv2.destroyAllWindows()
path = 'C:/Users/Aldrin Gwapo/Documents/Thesis 1/processed_frames'
count = 0
ret = 1
while ret: #CTRL C at console/terminal to force stop loop
ret, frame = video.read()
frame = cv2.resize(frame, (640, 480))
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
l_green = np.array([46, 34, 27])
u_green = np.array([82, 255, 255])
mask = cv2.inRange(hsv, l_green, u_green)
edges = cv2.Canny(mask, 150, 200)
res = cv2.bitwise_and(frame, frame, mask=mask)
contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
f = frame - res
f = np.where(f == 0, blackimage, image)
cv2.drawContours(f, contours, -1, (255, 255, 255), 3)
count += 1
cv2.imwrite(os.path.join(path, "ALframe" + str(count) + ".jpg"), f)
#CTRL C at console/terminal to force stop loop
#cv2.imshow("video", f) #comment out to view continous frames
#cv2.imshow("edges", edges)
#k=cv2.waitKey(1)
#if cv2.waitKey(25) == 27: #comment out if viewing frames and press escape to stop.
def main():
drone = tellopy.Tello()
try:
drone.connect()
drone.wait_for_connection(60.0)
retry = 3
container = None
while container is None and 0 < retry:
retry -= 1
try:
# 動画の受信開始を処理
container = av.open(drone.get_video_stream())
except av.AVError as ave:
print(ave)
print('retry...')
frame_skip = 300
while True:
for frame in container.decode(video=0):
if 0 < frame_skip: #フレームスキップ処理
frame_skip = frame_skip - 1
continue
start_time = time.time()
#img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
image_origin = cv2.cvtColor(np.array(frame.to_image()), cv2.COLOR_RGB2BGR)
img_mask = cv2.GaussianBlur(image_origin, (15, 15), 0) #フィルタの中の引数
canny = cv2.Canny(img_mask, 100, 150)
#色の抽出
def red_detect(canny):
RGBLower1 = np.array([62, 60, 100]) # 抽出する色の下限(BGR)
RGBUpper1 = np.array([75 ,80, 137]) # 抽出する色の上限(BGR)
mask1 = cv2.inRange(img_mask, RGBLower1, RGBUpper1)
#RGBLower2 = np.array([202, 185, 115])
#RGBUpper2 = np.array([255, 255, 148])
#mask2 = cv2.inRange(image_origin,RGBLower2, RGBUpper2)
return mask1
mask = red_detect(canny)
#img_mask = cv2.GaussianBlur(mask, (15, 15), 0) #フィルタの中の引数
#canny = cv2.Canny(img_mask, 200, 300)
fig = plt.figure(figsize=(15,15))
ax = fig.add_subplot(1,1,1)
ax.imshow(mask)
ax.axis("off")
#輪郭の抽出
#輪郭の階層情報
image, contours, hierarchy = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
i = 0
for contour in contours:
#for i in range(6):
cv2.drawContours(image_origin, contours, i, (255,0,0), 5)
S = cv2.contourArea(contours[i])
if S>0:
print(S)
i += 1
#for counter in counters:
#x, y, w, h ~ cv2.boundingRect(contour)
#cv2.rectangle(image_origin, (x,y), (x+w, y+h), (0,255,0),3)
#print(x)
#print(y)
#priny(w)
#print(h)
# Harrisコーナ検出
#mask = np.uint16(mask)
#gray = cv2.cvtColor(mask,cv2.COLOR_BGR2GRAY)
#mask = np.float32(mask)
#dst = cv2.cornerHarris(mask, 2, 9, 0.16)
# 青の点を頂点に打つ
#mask[dst>0.01*dst.max()] = [255,0,0]
#青のpixelを探す
#coord = np.where(np.all(mask == (255, 0, 0), axis = -1))
#printt coorsdinate
#for i in range(len(coord[0])):
#print("X:%s Y:%s"%(coord[1][i],coord[0][i]))
#for countour in contours:
#x, y, w, h = cv2.boundingRect(contour)
# cv2.rectangle(image_origin, (x,y), (x+w, y+h), (255,0,0),3)
#S = w * h
# print("x: " + str(x))
# print("y: " + str(y))
#print("w: " + str(w))
# print("h: " + str(h))
# print("S: " + str(S))
# GoodFeaturesToTrack
#corners = cv2.goodFeaturesToTrack(canny,100000000,0.01,10)
#corners = np.int0(corners)
#for i in corners:
#x,y = i.ravel()
#cv2.circle(img,(x,y),3,255,-1)
#print(x,y)
cv2.imshow('mask', mask)
cv2.imshow('image_origin', image_origin)
cv2.waitKey(1)
if frame.time_base < 1.0/60:
time_base = 1.0/60
else:
time_base = frame.time_base
# フレームスキップ値を算出
frame_skip = int((time.time() - start_time) / time_base)
except Exception as ex:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
print(ex)
finally:
drone.quit()
cv2.destroyAllWindows()
def tracker(video_path,
background_full,
rois,
threshold=5,
display=True,
area_size=0,
split_range=False):
""" Function that takes a video path, a background file, rois, threshold and display switch. This then uses
background subtraction and centroid tracking to find the XZ coordinates of the largest contour. Saves out a csv file
with frame #, X, Y, contour area"""
print("tracking {}".format(video_path))
# As camera is often excluded, check here and buffer if not included
if len(rois) == 1:
rois['cam'] = 'unknown'
# load video
video = cv2.VideoCapture(video_path)
if display:
# create display window
cv2.namedWindow("Live thresholded")
cv2.namedWindow("Live")
# as there can be multiple rois the writer, data and moviename are kept in lists
data = list()
frame_id = 0
for roi in np.arange(0, len(rois) - 1):
data.append(list())
if split_range is False:
total = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
split_range = [0, total + 1]
split_name = False
else:
split_name = True
while video.isOpened():
ret, frame = video.read()
if not ret:
print("reached end of video")
video.release()
break
if frame_id in np.arange(split_range[0], split_range[1]):
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frameDelta_full = cv2.absdiff(background_full, gray)
# tracking
cx = list()
cy = list()
contourOI = list()
contourOI_ = list()
for roi in range(0, len(rois) - 1):
# for the frame define an ROI and crop image
curr_roi = rois["roi_" + str(roi)]
frameDelta = frameDelta_full[curr_roi[1]:curr_roi[1] +
curr_roi[3],
curr_roi[0]:curr_roi[0] +
curr_roi[2]]
image_thresholded = cv2.threshold(frameDelta, threshold, 255,
cv2.THRESH_TOZERO)[1]
(contours, _) = cv2.findContours(image_thresholded,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
contourOI_.append(max(contours, key=cv2.contourArea))
area = cv2.contourArea(contourOI_[roi])
if area > area_size:
contourOI.append(cv2.convexHull(contourOI_[roi]))
M = cv2.moments(contourOI[roi])
cx.append(int(M["m10"] / M["m00"]))
cy.append(int(M["m01"] / M["m00"]))
data[roi].append((frame_id, cx[roi], cy[roi], area))
else:
print(
"no large enough contour found for roi {}!".format(
roi))
data[roi].append((frame_id, np.nan, np.nan, np.nan))
contourOI_[-1] = False
contourOI.append(False)
cx.append(np.nan)
cy.append(np.nan)
else:
print("no contour found for roi {}!".format(roi))
data[roi].append((frame_id, np.nan, np.nan, np.nan))
contourOI_.append(False)
contourOI.append(False)
cx.append(np.nan)
cy.append(np.nan)
if frame_id % 500 == 0:
print("Frame {}".format(frame_id))
if display:
full_image_thresholded = (cv2.threshold(
frameDelta_full, threshold, 255, cv2.THRESH_TOZERO)[1])
# Live display of full resolution and ROIs
cv2.putText(full_image_thresholded,
"Framenum: {}".format(frame_id),
(30, full_image_thresholded.shape[0] - 30),
cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=255)
for roi in range(0, len(rois) - 1):
if np.all(contourOI_[roi] != False):
curr_roi = rois["roi_" + str(roi)]
# add in contours
corrected_contour = np.empty(contourOI_[roi].shape)
corrected_contour[:, 0,
0] = contourOI_[roi][:, 0,
0] + curr_roi[0]
corrected_contour[:, 0,
1] = contourOI_[roi][:, 0,
1] + curr_roi[1]
cv2.drawContours(full_image_thresholded,
corrected_contour.astype(int), -1,
255, 1)
# add in centroid
cv2.circle(
full_image_thresholded,
(cx[roi] + curr_roi[0], cy[roi] + curr_roi[1]), 8,
255, 1)
cv2.imshow("Live thresholded", full_image_thresholded)
cv2.imshow("Live", gray)
cv2.waitKey(1)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frame_id += 1
# saving data
print("Saving data output")
date = datetime.datetime.now().strftime("%Y%m%d")
for roi in range(0, len(rois) - 1):
datanp = np.array(data[roi])
if split_name is False:
filename = video_path[
0:-4] + "_tracks_{}_Thresh_{}_Area_{}_roi-{}.csv".format(
date, threshold, area_size, roi)
else:
range_s = str(split_range[0]).zfill(5)
range_e = str(split_range[1]).zfill(5)
filename = video_path[
0:-4] + "_tracks_{}_Thresh_{}_Area_{}_Range{}-{}_.csv".format(
date, threshold, area_size, range_s, range_e)
os.makedirs(os.path.dirname(filename), exist_ok=True)
np.savetxt(filename, datanp, delimiter=",")
print("Tracking finished on video cleaning up")
cv2.destroyAllWindows()
mask = cv2.inRange(hsv_img, (29, 102, 0), (48, 255, 255))
## Visualize the mask
res = cv2.bitwise_and(frame, frame, mask=mask)
cv2.imshow("result", res)
cv2.imshow("mask", mask)
## erosion and dilation (not necessary)
## Processing to get better contours
kernel = np.ones((3, 3))
erosion = cv2.erode(mask, kernel, iterations=1)
dilation = cv2.dilate(erosion, kernel, iterations=1)
mask = dilation.copy()
## Finding contours
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if cnts:
# Find the maximum area contour and drawing bounding rectangle
C_max = max(cnts, key=cv2.contourArea)
x, y, w, h = cv2.boundingRect(C_max)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 255), 2)
mid_x = int(x + (w / 2))
mid_y = int(y + (h / 2))
frame = cv2.circle(frame, (mid_x, mid_y),
radius=5,
color=(0, 0, 255),
thickness=-1)
msg.x = mid_x
msg.y = mid_y
pub.publish(msg)
r.sleep()
import numpy as np
img = cv.imread('imagen/wppstalkerlarge.jpg')
cv.imshow('stalker', img)
blank = np.zeros(img.shape, dtype='uint8')
cv.imshow('blank', blank)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
cv.imshow('Gray', gray)
grayblurred = cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT)
#corners
canny = cv.Canny(grayblurred, 125, 175)
cv.imshow('CannyEdges', canny)
#corners can also be found by threesholding
#threeshold
#ret, thresh = cv.threshold(gray, 125, 255, cv.THRESH_BINARY)
#cv.imshow('Thresh', thresh)
#contours
contours, hierarchies = cv.findContours(canny, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)
print(f'{len(contours)} contour(s) found!')
cv.drawContours(blank, contours, -1, (0,255,0), 1)
cv.imshow('contoursDrawn', blank)
cv.waitKey(0)
thresh = cv2.threshold(gradX, 0 , 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
# apply the close operation this time using squrKernel to close the gaps
# in between lines of MRZ, then perform erosion to break apart connect components
thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, squrKernel)
thresh = cv2.erode(thresh, None, iterations=4)
# during thresholding, it's possible that border pixels were
# included in the thresholding, so let's set 5% of the left and
# right borders to zero
reducePercentage = int(image.shape[1] * 0.05)
thresh[:, 0:reducePercentage] = 0
thresh[:, image.shape[1] - reducePercentage:] = 0
# find contours in image ans sort them by thier size
contours = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = imutils.grab_contours(contours)
contours = sorted(contours, key=cv2.contourArea, reverse=True)
ROI = []
for contour in contours:
# compute bounding box, aspratio, width to the width of the image
(x, y, w, h) = cv2.boundingRect(contour)
aspratio = w / float(h)
crWidth = w / float(gray.shape[1])
print(aspratio, crWidth)
# check the acceptance criteria
if aspratio > 5 and crWidth > 0.7 :
# apply padding to re-grow image since used erosions
pX = int((x + w) * 0.03)
pY = int((y + h) * 0.03)
def gameControllerFunction(topLeft, centerLeft, bottomLeft, topCenter, middle, bottomCenter, topRight, centerRight, bottomRight):
print("Booting the Video stream,")
vs = cv2.VideoCapture(0) # start the video stream.
time.sleep(2.0) # set sleep time to 2.0 seconds
while True:
frame = vs.read() # Read off the frame from the video stream
ret, frame = frame # Use this if you want to load in your video
output = "None"
key = None
if frame is None: # If there is no frame, save my pc from going through any stress at all
break
# otherwise, if we have a frame, we proceed with the following code
# so much easier than open cv, keeping aspect ratio intact
frame = imutils.resize(frame, width=700)
# i want the mirror view, it's very helpful especially if i'm streaming
frame = cv2.flip(frame, 1)
windowDetails = cv2.getWindowImageRect('frame')
# print(windowDetails)
totalWidth = windowDetails[2]
totalHeight = windowDetails[3]
verLine1 = {
'start': (totalWidth//3, 0),
'end': (totalWidth//3, totalHeight)
}
verLine2 = {
'start': (totalWidth//3 * 2, 0),
'end': (totalWidth//3 * 2, totalHeight)
}
horLine1 = {
'start': (0, totalHeight//3),
'end': (totalWidth, totalHeight//3)
}
horLine2 = {
'start': (0, totalHeight//3 * 2),
'end': (totalWidth, totalHeight//3 * 2)
}
# processing the frame
# blurr helps to reduce high frequency noise, definately helps model
blurred = cv2.GaussianBlur(frame, (11, 11), 0)
# convert my color to the HSV format
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
# Create a mask
# mask other regions except colors in range of upper to lower (thresholding)
mask = cv2.inRange(hsv, lower_color_boundary, upper_color_boundary)
# Reduce noise caused by thresholding
mask = cv2.erode(mask, None, iterations=2)
# foreground the found object i.e futher reduce noise.
mask = cv2.dilate(mask, None, iterations=2)
contours = cv2.findContours(
mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # find contours
# Grab the contours using imutils
contours = imutils.grab_contours(contours)
center = None # center is initially set to none
if len(contours) > 0: # if the contours list is not empty proceed
# select contour with maximum Area, most likely our object
contour = max(contours, key=cv2.contourArea)
# pick up co-ordinates for drawing a circle around the object
((x, y), radius) = cv2.minEnclosingCircle(contour)
M = cv2.moments(contour) # Extract moments from the contour.
# Obtain the centre of mass of the object.
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
if radius > 10: # if we have a reasonable radius for the proposed object detected
# Draw a circle to bound the Object
cv2.circle(frame, (int(x), int(y)),
int(radius), (0, 255, 255), 2)
# Draw a filled in dot at the centre of the circle
cv2.circle(frame, center, 5, (0, 0, 225), -1)
if center:
if center[0] <= totalWidth//3:
if center[1] <= totalHeight//3:
output = "Top Left"
key = topLeft
elif center[1] >= totalHeight//3*2:
output = "Bottom Left"
key = bottomLeft
else:
output = "Center Left"
key = centerLeft
elif center[0] >= totalWidth//3*2:
if center[1] <= totalHeight//3:
output = "Top Right"
key = topRight
elif center[1] >= totalHeight//3*2:
output = "Bottom Right"
key = bottomRight
else:
output = "Center Right"
key = centerRight
else:
if center[1] <= totalHeight//3:
output = "Top Center"
key = topCenter
elif center[1] >= totalHeight//3*2:
output = "Bottom Center"
key = bottomCenter
else:
output = "Center"
key = middle
if key:
key_arr = key.split('+')
# Key Presses
for k in key_arr:
pyautogui.keyDown(k.strip())
time.sleep(0.08)
for k in key_arr:
pyautogui.keyUp(k.strip())
# Drawing the grid
cv2.putText(frame, output, (50, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2, cv2.LINE_4)
cv2.line(frame, verLine1['start'], verLine1['end'], (255, 255, 255), 5)
cv2.line(frame, verLine2['start'], verLine2['end'], (255, 255, 255), 5)
cv2.line(frame, horLine1['start'], horLine1['end'], (255, 255, 255), 5)
cv2.line(frame, horLine2['start'], horLine2['end'], (255, 255, 255), 5)
cv2.imshow("frame", frame) # let's see the frame X frame
# Closing a video frame
key = cv2.waitKey(1) # wait for the cv key
if key == ord("q"): # If the x button is pressed
break # Break from the loop
vs.release() # Let opencv release the video loader
cv2.destroyAllWindows() # Destroy all windows to close it
root_path = os.getcwd()
img = cv.imread(root_path + '/image_processing/datas/images/namecard.png')
if img is None:
print("Error opening video stream or file")
sys.exit()
img = cv.resize(img, (0, 0), fx=0.3, fy=0.3)
img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
_, img_binary = cv.threshold(img_gray, 0, 255,
cv.THRESH_BINARY | cv.THRESH_OTSU)
contours, _ = cv.findContours(img_binary, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_NONE)
dw, dh = 900, 500
import pytesseract
for pts in contours:
if cv.contourArea(pts) > 5000:
approx = cv.approxPolyDP(pts, cv.arcLength(pts, True) * 0.02, True)
if len(approx) == 4 and cv.isContourConvex(approx):
cv.polylines(img, pts, True, (0, 0, 255))
srcQuad = reorderPts(approx.reshape(4, 2))
dstQuad = np.array([[0, dh], [dw, dh], [dw, 0], [0, 0]],
dtype=np.float32)
pers = cv.getPerspectiveTransform(srcQuad, dstQuad)
img_dst = cv.warpPerspective(img,
pers, (dw, dh),
# Load image
img = cv2.imread('test2.jpg', cv2.IMREAD_COLOR)
# Resize image
#img = cv2.resize(img, (700, 580)) #Done with img = test5
img = cv2.resize(img, (620, 480)) #Done with img = test2
# Edge detection
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # convert to grey scale
gray = cv2.bilateralFilter(gray, 11, 17, 17) # Blur to reduce noise
edged = cv2.Canny(gray, 30, 200) # Perform Edge detection
# find contours in the edged image, keep only the largest
# ones, and initialize our screen contour
cnts = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)
screenCnt = None
# loop over our contours
for c in cnts:
# approximate the contour
peri = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.05 * peri, True)
# if our approximated contour has four points, then
# we can assume that we have found our screen
if len(approx) == 4 and max_size > cv2.contourArea(c) > min_size:
screenCnt = approx
break
img = cv2.GaussianBlur(bla,(3,3),0)
laplacian = cv2.Laplacian(img,cv2.CV_8UC1)
edges = cv2.Canny(img,100,100)
plot_images(blur, edges)
cv2.imwrite("data/images/blr.png", laplacian)
image_pat = "{}/{}".format(images_dir, "blr.png")
edg = cv2.imread(image_pat)
_, cnts, new = cv2.findContours(edges.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
image_copy = image.copy()
_ = cv2.drawContours(image_copy, cnts, -1, (106,0,255),2)
plot_images(image, image_copy)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:1000]
image_copy = image.copy()
_ = cv2.drawContours(image_copy, cnts, -1, (255,0,255),2)
plot_images(image, image_copy)
plate = None
from cv2 import cv2
from PIL import Image
from pylab import *
from scipy.ndimage import filters
import pytesseract
pytesseract.tesseract_cmd = '/usr/local/bin/tesseract'
image = cv2.imread('ind_1.jpg')
cv2.imshow("Original", image)
im2 = filters.gaussian_filter(image, 0.2)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edged = cv2.Canny(im2, 170, 200)
contours, heirarchy = cv2.findContours(edged.copy(), cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)[:30]
for c in contours:
length = cv2.arcLength(c, closed=True)
approx = cv2.approxPolyDP(c, 0.02 * length, closed=True)
if len(approx) == 4: # Select the contour with 4 corners
numberplate = approx #This is our approx Number Plate Contour
break
else:
numberplate = None
# Drawing the selected contour on the original image
#cv2.drawContours(image, [numberplate], -1, (0,255,0), 3)
x = numberplate
a = min(x[0][0][1], x[2][0][1])
