def createWindow(self):
cv2.namedWindow(self._windowName)#创建视屏窗口
self._isWindowCreated = True#修改类属性,说明已经创建窗口,为Ture
import numpy as np
from cv2 import cv2 as cv
def nada(x):
pass
#criação de uma imagem preta e de uma janela
img = np.zeros((300,512,3), np.uint8)
cv.namedWindow('image')
#criação das trackbar para troca de cor. O último parâmetro é uma função que executa toda vez que algo muda
cv.createTrackbar('R','image',0,255,nada)
cv.createTrackbar('G','image',0,255,nada)
cv.createTrackbar('B','image',0,255,nada)
# criação de um "interruptor" que liga e desliga a funcionalidade
switch = '0 : OFF \n1 : ON'
cv.createTrackbar(switch, 'image',0,1,nada)
while(1):
cv.imshow('image',img)
k = cv.waitKey(1) & 0xFF
if k == 27:
break
# pega a posição atual das quatro trackbar
r = cv.getTrackbarPos('R','image')
g = cv.getTrackbarPos('G','image')
b = cv.getTrackbarPos('B','image')
s = cv.getTrackbarPos(switch,'image')
if s == 0:
img[:] = 0 #seta a imagem toda preta
else:
from cv2 import cv2 as cv
src = cv.imread('foreward.jpeg')
cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE)
cv.imshow('input_image', src)
cv.waitKey(0)
cv.destroyAllWindows()
def main():
button_pin = 7
GPIO.setmode(GPIO.BCM)
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(prototxt, model)
# initialize the video stream, allow the cammera sensor to warmup,
# and initialize the FPS counter
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
fps = FPS().start()
ultrasonic = UltrasonicSystem({1: [8, 25], 2: [24, 23], 3: [15, 14]}, 3)
ultrasonic.add_sensors()
ultrasonic_spawn = threading.Thread(target=ultrasonic.spawn_sensor_threads,
daemon=True)
ultrasonic_spawn.start()
GPIO.add_event_detect(button_pin, GPIO.RISING)
try:
# loop over the frames from the video stream
while True:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 500 pixels
frame = vs.read()
frame = cv2.flip(frame, 1)
# grab the frame dimensions and convert it to a blob
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)),
0.007843, (300, 300), 127.5)
# pass the blob through the network and obtain the detections and
# predictions
net.setInput(blob)
detections = net.forward()
# loop over the detections
for i in np.arange(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the prediction
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the `confidence` is
# greater than the minimum confidence
if confidence > confidence_threshold:
# extract the index of the class label from the
# `detections`, then compute the (x, y)-coordinates of
# the bounding box for the object
idx = int(detections[0, 0, i, 1])
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# draw the prediction on the frame
label = "{}: {:.2f}%".format(CLASSES[idx],
confidence * 100)
cv2.rectangle(frame, (startX, startY), (endX, endY),
COLORS[idx], 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(frame, label, (startX, y),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2)
frame = ultrasonic.write_measurements_to_frame(frame)
# show the output frame
cv2.namedWindow("Frame", cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty("Frame", cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
# cv2.resizeWindow("Frame", 640, 480)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if GPIO.event_detected(button_pin):
ultrasonic.stop = True
time.sleep(1)
break
# update the FPS counter
fps.update()
cleanup(fps, vs)
except KeyboardInterrupt:
cleanup(fps, vs)
drawing = False # true if mouse is pressed
ix, iy = -1, -1
def draw_shape(event, x, y, flags, param): # mouse callback func
global ix, iy, drawing
if event == cv.EVENT_LBUTTONDOWN:
drawing = True
ix, iy = x, y
elif event == cv.EVENT_MOUSEMOVE:
if drawing == True:
cv.rectangle(img, (ix, iy), (x, y), (0, 255, 0), 0)
elif event == cv.EVENT_LBUTTONUP:
drawing = False
cv.rectangle(img, (ix, iy), (x, y), (0, 255, 0),
2) # if thickness -1 = fill
cv.imshow("Image", img)
img = np.zeros((512, 512, 3), np.uint8)
while True:
cv.namedWindow("Image", cv.WINDOW_NORMAL)
cv.imshow("Image", img)
cv.setMouseCallback("Image", draw_shape)
cv.waitKey(0)
cv.destroyAllWindows()
dst = cv.divide(m1, m2)
cv.imshow("divide_demo", dst)
def multiply_demo(m1, m2): # 两张图片需要同样大
dst = cv.multiply(m1, m2)
cv.imshow("multiply_demo", dst)
def logic_demo(m1, m2):
dst = cv.bitwise_and(m1, m2)
cv.imshow("logic_demo", dst)
def contrast_brightness_demo(image, c, b):
h, w, ch = image.shape
blank = np.zeros([h, w, ch], image.dtype)
dst = cv.addWeighted(image, c, blank, 1 - c, b)
cv.imshow("con-bri-demo", dst)
src1 = cv.imread("")
src2 = cv.imread("")
cv.namedWindow("image1", cv.WINDOW_AUTOSIZE)
cv.imshow("image1", src1)
cv.imshow("image2", src2)
add_demo(src1, src2)
cv.waitKey(0)
cv.destroyAllWindows()
else:
img_path = args.image_path
img = cv2.imread(img_path, cv2.IMREAD_COLOR)
img_copy = img.copy()
img_to_cut = img.copy()
while True:
if video:
_, img = cam.read()
img_to_cut = img.copy()
cv2.imshow('image', img)
key = cv2.waitKey(100)
if key == 115: # 's'
cv2.namedWindow('select points')
cv2.setMouseCallback('select points', get_mouse_points)
selecting_points = True
if selecting_points:
if get_frame and video:
img_copy = img.copy()
get_frame = False
cv2.imshow('select points', img_copy)
if key == 99 and len(all_points) > 2 and selecting_points: # 'c'
selected_points = True
selecting_points = False
cv2.setMouseCallback(
'select points', lambda event, x, y, flags, param: None)
img = cv2.erode(img, None, iterations=2) #1
img = cv2.dilate(img, None, iterations=4) #2
img = cv2.medianBlur(img, 5) #3
img2 = np.copy(img)
h, w = img.shape
keypoints = self.detector.detect(img)
return keypoints, img2
def nothing(x):
pass
cv2.namedWindow('image3')
cv2.namedWindow('image')
cv2.createTrackbar('tresh_r', 'image3', 0, 255, nothing)
cv2.createTrackbar('tresh_l', 'image3', 0, 255, nothing)
cv2.namedWindow('image2')
el = eye('l')
er = eye('r')
def find_eyes(frame):
frame = cv2.rectangle(frame, el.ld, el.ur, (0, 255, 0), 1)
frame = cv2.rectangle(frame, er.ld, er.ur, (0, 255, 0), 1)
return frame
def do_frame(frame):
# start the video stream thread
print('[INFO] starting video stream thread...')
vs = FileVideoStream(args['video']).start()
fileStream = True
vs = VideoStream(src=0).start()
# vs = FileVideoStream(args["video"]).start()
fileStream = False
time.sleep(1.0)
# opening windows to display images and moving them to right positions
cv2.namedWindow('Frame')
cv2.moveWindow('Frame', 0, 0)
cv2.namedWindow('Left Eye')
cv2.moveWindow('Left Eye', 550, 0)
cv2.namedWindow('Equalized Left Eye')
cv2.moveWindow('Equalized Left Eye', 550, 300)
cv2.namedWindow('Right Eye')
cv2.moveWindow('Right Eye', 950, 0)
cv2.namedWindow('Equalized Right Eye')
cv2.moveWindow('Equalized Right Eye', 950, 300)
img_no = 0
phone_call_done = 0
flashlight_done = 0
def Q_B(event, x, y, flag, param):
global score, img, QB
if event == cv2.EVENT_LBUTTONDOWN:
if not QB[y][x].any() == 0:
stp_x = y // img.shape[0]
stp_y = x // img.shape[1]
for a in range(1, img.shape[0]):
for b in range(1, img.shape[1]):
QB[stp_x * img.shape[0] + a][stp_y * img.shape[1] +
b] = (0, 0, 0)
score += 1
path = os.getcwd()
img = cv2.imread(path + '\\QB.jpg')
cv2.namedWindow('QB')
cv2.setMouseCallback('QB', Q_B)
while (1):
QB = numpy.zeros((img.shape[0] * 3, img.shape[1] * 3 + 139, img.shape[2]),
dtype=numpy.uint8)
for a in range(0, 3):
for b in range(0, 3):
stp = random.randint(0, 1)
if (stp):
for c in range(0, img.shape[0]):
for d in range(0, img.shape[1]):
QB[a * img.shape[0] + c][b * img.shape[1] +
d] = img[c][d]
cv2.rectangle(QB, (b * img.shape[1], a * img.shape[0]),
((b + 1) * img.shape[1], (a + 1) * img.shape[0]),
(187, 197, 57), 1)
"test"
from cv2 import cv2
import numpy as np
img = cv2.imread('Data/00.jpg')
cv2.namedWindow('Window', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Window', 600, 600)
cv2.imshow('Window', img)
#cv2.imwrite('Output/test.png', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def yolo():
#camera = cv2.VideoCapture(0)
h, w = None, None
"""
End of:
Reading stream video from camera
"""
"""
Start of:
Loading YOLO v3 network
"""
with open('yolo-coco-data/coco.names') as f:
labels = [line.strip() for line in f]
network = cv2.dnn.readNetFromDarknet('yolo-coco-data/yolov3.cfg',
'yolo-coco-data/yolov3.weights')
layers_names_all = network.getLayerNames()
layers_names_output = \
[layers_names_all[i[0] - 1] for i in network.getUnconnectedOutLayers()]
probability_minimum = 0.5
threshold = 0.3
colours = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8')
"""
End of:
Loading YOLO v3 network
"""
"""
Start of:
Reading frames in the loop
"""
start_time = time.time()
seconds = 10
img = cv2.imread('Car.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img2 = cv2.imread('Person.png')
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
print('Our two images are')
# plt.imshow(img)
# plt.show()
# plt.imshow(img2)
# plt.show()
print('Objects are: ')
all_objects = []
k = 1
while (k):
#_, frame = camera.read()
frame = img
if (k == 2):
frame = img2
if w is None or h is None:
h, w = frame.shape[:2]
current_time = time.time()
elapsed_time = current_time - start_time
if elapsed_time > seconds:
# Releasing camera
#camera.release()
# Destroying all opened OpenCV windows
cv2.destroyAllWindows()
break
"""
Start of:
Getting blob from current frame
"""
blob = cv2.dnn.blobFromImage(frame,
1 / 255.0, (416, 416),
swapRB=True,
crop=False)
"""
End of:
Getting blob from current frame
"""
"""
Start of:
Implementing Forward pass
"""
network.setInput(blob) # setting blob as input to the network
#start = time.time()
output_from_network = network.forward(layers_names_output)
#end = time.time()
#print('Current frame took {:.5f} seconds'.format(end - start))
"""
End of:
Implementing Forward pass
"""
"""
Start of:
Getting bounding boxes
"""
bounding_boxes = []
confidences = []
class_numbers = []
for result in output_from_network:
# Going through all detections from current output layer
for detected_objects in result:
# Getting 80 classes' probabilities for current detected object
scores = detected_objects[5:]
# Getting index of the class with the maximum value of probability
class_current = np.argmax(scores)
# Getting value of probability for defined class
confidence_current = scores[class_current]
if confidence_current > probability_minimum:
box_current = detected_objects[0:4] * np.array(
[w, h, w, h])
x_center, y_center, box_width, box_height = box_current
x_min = int(x_center - (box_width / 2))
y_min = int(y_center - (box_height / 2))
bounding_boxes.append(
[x_min, y_min,
int(box_width),
int(box_height)])
confidences.append(float(confidence_current))
class_numbers.append(class_current)
if (k == 2):
k = 0
if (k == 1):
k = 2
"""
End of:
Getting bounding boxes
"""
"""
Start of:
Non-maximum suppression
"""
results = cv2.dnn.NMSBoxes(bounding_boxes, confidences,
probability_minimum, threshold)
"""
End of:
Non-maximum suppression
"""
"""
Start of:
Drawing bounding boxes and labels
"""
if len(results) > 0:
# Going through indexes of results
for i in results.flatten():
#speech output
obj = labels[int(class_numbers[i])]
#if obj in all_objects:
# continue
#else:
all_objects.append(obj)
#text = "There is a "+obj+" in front of you."
#language = 'en'
#speech = gTTS(text = text, lang = language, slow = False)
#speech.save("text.wav")
#os.system("text.wav")
x_min, y_min = bounding_boxes[i][0], bounding_boxes[i][1]
box_width, box_height = bounding_boxes[i][2], bounding_boxes[
i][3]
colour_box_current = colours[class_numbers[i]].tolist()
#cv2.rectangle(frame, (x_min, y_min),
# (x_min + box_width, y_min + box_height),
# colour_box_current, 2)
# plt.imshow(cv2.rectangle(frame, (x_min, y_min),
# (x_min + box_width, y_min + box_height),
# colour_box_current, 2))
# plt.show()
arr = cv2.rectangle(frame, (x_min, y_min),
(x_min + box_width, y_min + box_height),
colour_box_current, 2)
img = Image.fromarray(arr.astype('uint8'))
# create file-object in memory
file_object = io.BytesIO()
# write PNG in file-object
img.save(file_object, 'PNG')
# move to beginning of file so `send_file()` it will read from start
file_object.seek(0)
return send_file(file_object, mimetype='image/PNG')
print(obj)
print(x_min)
print(y_min)
print(box_width)
print(box_height)
text_box_current = '{}: {:.4f}'.format(
labels[int(class_numbers[i])], confidences[i])
cv2.putText(frame, text_box_current, (x_min, y_min - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, colour_box_current,
2)
#print(len(all_objects))
"""
End of:
Drawing bounding boxes and labels
"""
"""
Start of:
Showing processed frames in OpenCV Window
"""
cv2.namedWindow('YOLO v3 Real Time Detections', cv2.WINDOW_NORMAL)
# Pay attention! 'cv2.imshow' takes images in BGR format
cv2.imshow('YOLO v3 Real Time Detections', frame)
# Breaking the loop if 'q' is pressed
if cv2.waitKey(1) & 0xFF == ord('q'):
break
"""
End of:
Showing processed frames in OpenCV Window
"""
"""
End of:
Reading frames in the loop
"""
for i in all_objects:
print(i)
# Releasing camera
#camera.release()
# Destroying all opened OpenCV windows
cv2.destroyAllWindows()
return send_file(file_object, mimetype='image/PNG')
def getVideo_Info(modelpath, video_path, output_path=""):
from cv2 import cv2
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
raise IOError("Couldn't open webcam or video")
video_FourCC = int(cap.get(cv2.CAP_PROP_FOURCC)) # 获取原始视频的信息
video_fps = cap.get(cv2.CAP_PROP_FPS)
video_size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
isOutput = True if output_path != "" else False # 如果设置了视频保存路径，则保存视频
if isOutput:
print("!!! TYPE:", type(output_path), type(video_FourCC),
type(video_fps), type(video_size))
out = cv2.VideoWriter(output_path, video_FourCC, video_fps,
video_size) # 根据原视频设置 保存视频的路径、大小、帧数
accum_time = 0
curr_fps = 0
fps = "FPS: ??"
prev_time = time.time()
yolo = YOLO()
pose_model = general_coco_model(modelpath) # 1.加载模型
while True:
return_value, frame = cap.read()
if return_value:
# 骨骼
bone_points = pose_model.getBoneKeypoints(frame) # 2.骨骼关键点
lineimage, dotimage = pose_model.vis_bone_pose(
frame, bone_points) # 骨骼连线图、标记图显示
# list1 = getBoneInformation(bone_points) # 3.骨骼特征
temp, labelinfo = yolo.detect_image(
Image.fromarray(frame), Image.fromarray(lineimage)) # 检测PIL格式
result = np.asarray(temp) # 画图到全部图上
curr_time = time.time()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
fps = "FPS: " + str(curr_fps)
curr_fps = 0
cv2.putText(result,
text=fps,
org=(3, 15),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50,
color=(255, 0, 0),
thickness=2)
cv2.putText(result,
"q-'quit'",
org=(3, 45),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50,
color=(0, 255, 0),
thickness=2) # 标注字体
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
cv2.imshow("result", result)
if isOutput:
out.write(result)
else:
print("Frame is end!")
break
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def tracker(video_path,
background_full,
rois,
threshold=5,
display=True,
area_min=0,
area_max=1000,
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_min) and (area < area_max):
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_min, 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_min, 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()
input_image = os.path.join('', "", filename_input)
input_mask = os.path.join('', "", filename_mask)
output_image = os.path.join('', "", filename_output)
if filename_input is None:
print('File input not exist.')
exit()
img = cv2.imread(filename_input)
mask = np.zeros(img.shape, np.uint8)
# handle_remove(input_image, output_image, input_mask,
# mask, img)
img_copy = img.copy()
mask_copy = mask.copy()
window_name = 'Draw mask. s:save; r: reset; q:quit'
cv2.namedWindow(window_name)
cv2.setMouseCallback(window_name, draw_circle)
while True:
cv2.imshow(window_name, img)
k = cv2.waitKey(1) & 0xFF
# cv2.imshow('mask', mask)
if k == ord('r'):
img = img_copy.copy()
mask = mask_copy.copy()
elif k == ord("s"):
cv2.imwrite('mask.png', mask)
print('[INFO]: processing')
object_removal(input_image, output_image, input_mask)
break
elif k == ord("q"):
cv2.destroyAllWindows()
if event == cv2.EVENT_LBUTTONDOWN:
REF_POINT = [(x, y)]
print('mouse down', x, y)
elif event == cv2.EVENT_LBUTTONUP:
# record the ending (x, y) coordinates and indicate that
# the cropping operation is finished
REF_POINT.append((x, y))
RESULT_DICT[FIELD].append(REF_POINT)
print('mouse up', x, y)
# draw a rectangle around the region of interest
cv2.rectangle(IMAGE, REF_POINT[0], REF_POINT[1], (0, 255, 0), 2)
cv2.imshow("image", IMAGE)
print(RESULT_DICT)
cv2.namedWindow("image")
cv2.setMouseCallback("image", getBBs)
############################################################################################################
# Sort Pics
############################################################################################################
BREED_COUNT = 0
IMAGE_COUNT = 0
BREED = BREEDS[BREED_COUNT]
print('BREED:', BREED)
print(len(PICS), '# of pics')
PICS = pAnimals[pAnimals['breed'] == BREED].path.tolist()
def loadIm(breed, randPic=False):
from cv2 import cv2
import numpy as np
def read_cam(camId):
frameWidth = 440
frameHeight = 380
cap = cv2.VideoCapture(camId)
cap.set(3, frameWidth)
cap.set(4, frameHeight)
cap.set(10,150)
return cap
def empty(a):
pass
cv2.namedWindow("HSV")
cv2.resizeWindow("HSV",640,240)
cv2.createTrackbar("HUE Min","HSV",0,179,empty)
cv2.createTrackbar("SAT Min","HSV",0,255,empty)
cv2.createTrackbar("VALUE Min","HSV",0,255,empty)
cv2.createTrackbar("HUE Max","HSV",179,179,empty)
cv2.createTrackbar("SAT Max","HSV",255,255,empty)
cv2.createTrackbar("VALUE Max","HSV",255,255,empty)
cap = read_cam(0)
while True:
_, img = cap.read()
imgHsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
def _execute(self, payload):
frame = payload.original_frame
raw_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frames = self.frames
median = np.median(
frames, axis=0).astype(float) if len(frames) else np.ndarray(
(0, )) # .reshape(100, 100)
if len(self.detection_mask) == 0:
self.detection_mask = np.zeros(raw_gray.shape, dtype='uint8')
# df = payload.dfs.get('detections', pd.DataFrame()).drop_duplicates()
# if len(df) > 0:
vehicle_detections = list(payload.vehicle_detections)
boxes = (d.bounding_box for d in vehicle_detections)
# boxes = (b.get_scaled(0.5) for b in boxes)
bb_h_percentage = 0.2
boxes = [
BoundingBox(b.x, int(round(b.y + b.h * (1 - bb_h_percentage))),
b.w, int(round(b.h * bb_h_percentage))) for b in boxes
]
for box in boxes:
# y_start = max(0, box.y)
# y_end = max(box.y + box.h, 0)
# x_start = max(0, box.x)
# x_end = max(0, box.x + box.w)
# self.detection_mask[y_start: y_end, x_start:x_end] = 1
self.detection_mask[box.y:box.y + box.h, box.x:box.x + box.w] = 1
# cv2.imshow('detection_mask',self.detection_mask*255)
# cv2.waitKey(0)
gray = raw_gray.copy() # * (1 - self.detection_mask)
if len(median):
idxs = np.where(self.detection_mask == 1)
detections_median = np.median(median[idxs])
gray[idxs] = detections_median
self.frames.append(gray)
title = 'Median'
cv2.namedWindow(title, cv2.WINDOW_NORMAL)
if len(median):
cv2.imshow(title, median / 255)
# cv2.imshow(title, frame)
# cv2.imshow(title, gray / 255)
# cv2.imwrite(r'median.jpg', median, )
return payload
src = median / 255
from experimental import demo_erosion_dilatation
src = (1 - src) * 255
demo_erosion_dilatation(src, iterations=2)
erosion_size = 5
erosion_type = cv2.MORPH_ELLIPSE
element = cv2.getStructuringElement(
erosion_type, (2 * erosion_size + 1, 2 * erosion_size + 1),
(erosion_size, erosion_size))
erosion_dst = cv2.erode(src, element, iterations=1)
cv2.imshow('erosion', erosion_dst)
erosion_dst = cv2.dilate(src, element, iterations=2)
cv2.imshow('dialation', erosion_dst)
cv2.waitKey(0)
element = cv2.getStructuringElement(
erosion_type, (2 * erosion_size + 1, 2 * erosion_size + 1),
(erosion_size, erosion_size))
cv2.waitKey(1)
# ============================================
return payload
gt_bbox = get_gt_box(gt_box_file)
for i in range(gt_bbox.shape[0]):
label[gt_bbox[i, 2]:gt_bbox[i, 4], gt_bbox[i, 1]:gt_bbox[i, 3], 0] = gt_bbox[i, 0]
return label
def get_image(image_file):
image = np.array(Image.open(image_file))
height, width, channels = image.shape
image = image.astype((np.int32))
return image, height, width
main_box_dir = 'E:/02竞赛/水下目标检测/water_optical_comp/train/train/box/'
main_image_dir = 'E:/02竞赛/水下目标检测/water_optical_comp/train/train/image/'
for i in range(1,1000):
image_file = main_image_dir + str("%06d" % i) + '.jpg'
gt_box_file = main_box_dir + str("%06d" % i) + '.xml'
image, height, width = get_image(image_file)
label = get_label(gt_box_file, height, width) * 60
label = np.concatenate((label, label,label),axis=-1).astype(np.uint8)
image = image.astype(np.uint8)
cv2.namedWindow("image", 0)
cv2.resizeWindow("image", 640, 480)
cv2.imshow("image", image)
cv2.namedWindow("label", 0)
cv2.resizeWindow("label", 640, 480)
cv2.imshow('label' ,label)
cv2.waitKey(0)
# coding: utf-8
import numpy as np
from cv2 import cv2
print(cv2.useOptimized())
img_1 = cv2.imread(r'pictures\lena.jpg')
e1 = cv2.getTickCount()
for i in range(7, 24, 2):
img_1 = cv2.medianBlur(img_1, i)
e2 = cv2.getTickCount()
cv2.namedWindow("medianBlur")
cv2.imshow('medianBlur', img_1)
cv2.waitKey(0)
cv2.destroyAllWindows()
t = (e2 - e1)/cv2.getTickFrequency()
print('Process time: ',t, 's', sep='')
# Python scalar operations are faster than Numpy scalar operations. So for operations including one or two elements, Python scalar is better than Numpy arrays. Numpy takes advantage when size of array is a little bit bigger.
# Normally, OpenCV functions are faster than Numpy functions. So for same operation, OpenCV functions are preferred. But, there can be exceptions, especially when Numpy works with views instead of copies.
# Avoid using loops in Python as far as possible, especially double/triple loops etc. They are inherently slow.
# Vectorize the algorithm/code to the maximum possible extent because Numpy and OpenCV are optimized for vector operations.
# Exploit the cache coherence.
# Never make copies of array unless it is needed. Try to use views instead. Array copying is a costly operation.
# Even after doing all these operations, if your code is still slow, or use of large loops are inevitable, use additional libraries like Cython to make it faster.
# More performance optimization will learn in the future.
from cv2 import cv2
import numpy as np
def nothing(x):
pass
vid = cv2.VideoCapture(0)
cv2.namedWindow("Tracking")
cv2.createTrackbar("LH", "Tracking", 0, 255, nothing)
cv2.createTrackbar("LS", "Tracking", 0, 255, nothing)
cv2.createTrackbar("LV", "Tracking", 0, 255, nothing)
cv2.createTrackbar("UH", "Tracking", 255, 255, nothing)
cv2.createTrackbar("US", "Tracking", 255, 255, nothing)
cv2.createTrackbar("UV", "Tracking", 255, 255, nothing)
while True:
success, frame = vid.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
lh = cv2.getTrackbarPos("LH", "Tracking")
ls = cv2.getTrackbarPos("LS", "Tracking")
lv = cv2.getTrackbarPos("LV", "Tracking")
uh = cv2.getTrackbarPos("UH", "Tracking")
us = cv2.getTrackbarPos("US", "Tracking")
uv = cv2.getTrackbarPos("UV", "Tracking")
def draw_function(event, x, y, flags, param):
if event == cv2.EVENT_MOUSEMOVE:
global b, g, r, xpos, ypos, moved
moved = True
xpos = x
ypos = y
b, g, r = img[
y,
x] #BGR, since OpenCV represents images as NumPy arrays in reverse order
b = int(b)
g = int(g)
r = int(r)
cv2.namedWindow("colors_win")
cv2.setMouseCallback("colors_win", draw_function)
while (1):
cv2.imshow("colors_win", img)
if (moved):
#text display config
cv2.rectangle(img, (20, 20), (750, 60), (b, g, r), -1)
text = getName(r, g,
b) + " R=" + str(r) + " G=" + str(g) + " B=" + str(b)
cv2.putText(img, text, (50, 50), 2, 0.8, (255, 255, 255), 2,
cv2.LINE_AA)
import pyautogui
from cv2 import cv2
import numpy as np
resolution = (1366, 768) #Screen Resolution
codec = cv2.VideoWriter_fourcc(*"XVID") #codex
out = cv2.VideoWriter("Recorded.avi", codec, 60, resolution)
cv2.namedWindow("Recording", cv2.WINDOW_NORMAL)
cv2.resizeWindow("Recording", 480, 270)
while True:
img = pyautogui.screenshot() #capturing screenshot
frame = np.array(img) #converting the image into numpy array representation
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) #converting the BGR image into RGB image
out.write(frame) #writing the RBG image to file
cv2.imshow('Recording', frame) #display screen/frame being recorded
if cv2.waitKey(1) == ord('q'): #Wait for the user to press 'q' key to stop the recording
break
out.release()
cv2.destroyAllWindows()
def main(stream, photo):
with tf.compat.v1.Session() as sess:
# Get YOLOV3 model from tensornet and store it.
inputs = tf.compat.v1.placeholder(tf.float32, [None, 416, 416, 3])
model = nets.YOLOv3COCO(inputs, nets.Darknet19)
# Choose the class to identify. I'm only need the person class to count people.
classes = {'0' : 'person'}
indexOfClasses = [0]
# Train the model.
sess.run(model.pretrained())
# Launch webcam to capture the image from the camera. 0 is for the webcam.
webcamStream = cv.VideoCapture(photo)
# Start main loop for the webcam stream.
while(webcamStream.isOpened()):
# Get the image of the stream.
ret, frame = webcamStream.read()
# Create new image based on the stream shape.
img = cv.resize(frame, (416, 416))
imgTmp = np.array(img)
imgTmp = np.reshape(imgTmp, (-1, 416, 416, 3))
# Run model with the image of the stream for classification and identifying people.
preds = sess.run(model.preds, {inputs: model.preprocess(imgTmp)})
# Create boxes for people in the image.
boxes = model.get_boxes(preds, imgTmp.shape[1:3])
# Create a windows to display the image.
cv.namedWindow('image', cv.WINDOW_NORMAL)
cv.resizeWindow('image', 500, 500)
# Loop to create the boxes for people found in image if in it and draw the boxe around.
# Also display the number of classes identify. If 2 people on camera should display 'Number of person: 2'.
boxes1 = np.array(boxes)
for classe in indexOfClasses:
count = 0
label = classes[str(classe)]
if len(boxes1) != 0:
for index in range(len(boxes1[classe])):
box = boxes1[classe][index]
if boxes1[classe][index][4] >= .40:
count += 1
cv.rectangle(img, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)
cv.putText(img, label, (box[0], box[1]), cv.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), lineType=cv.LINE_AA)
print('Number of person: ', count)
# Display the image.
cv.imshow("image", img)
# If you give an image as input, show the image with the result for 5 secondes and stop the program.
if photo != 0:
cv.waitKey(5000)
webcamStream.release()
cv.destroyAllWindows()
break
# If you're in a real-time stream and you press 'q', this will quit stop the program.
if stream == True:
if cv.waitKey(1) & 0xFF == ord('q'):
webcamStream.release()
cv.destroyAllWindows()
break
#reads folder with pictures as processed frames
#user creates set of images
import argparse
import os
from cv2 import cv2
import numpy as np
#parser to point wich video we want to process in floder
parser = argparse.ArgumentParser(description='VID number.')
parser.add_argument('number', metavar='N', type=int, nargs=1, help='number of video to process')
parser.add_argument('frameN', metavar='F', type=int, nargs=1, help='video start frame number starting from 1')
args = parser.parse_args()
path='VID/15FPS/to_do' #main folder with videos
save_path = '/Pictures/cd'
path_to_folder=path + '/' + str(args.number[0])
cv2.namedWindow("old", cv2.WINDOW_NORMAL)
cv2.namedWindow("new", cv2.WINDOW_NORMAL)
class Found(Exception): pass
licznikY = 1684
licznikN = 2855
licznikSN = 1
con = 0
def numbers(img):
image = img.copy()
_, width = image.shape[:2]
n = int(width/224) #number of images
pixels = 50 #where to draw number
for i in range(n):
cv2.putText(image, str(i), (pixels, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
pixels += 224
# Check if drawing boundary boxes in span of images that has been selected.
if bounding_box.bounding_box_start_coordinates_x_y[2] in range(create_text_file.cell_numbers_list_for_each_grid[-2], \
create_text_file.cell_numbers_list_for_each_grid[-1]+1) \
or bounding_box.bounding_box_start_coordinates_x_y[2] in range(create_text_file.cell_numbers_list_for_each_grid[-1], \
create_text_file.cell_numbers_list_for_each_grid[-2]+1):
draw_boundary_box(x, y, bounding_box.bounding_box_start_coordinates_x_y)
# Check if camera opened successfully.
if not cap.isOpened():
print("Error opening video stream or file")
sys.exit()
index = 0
cv2.namedWindow('image_selector_from_video', cv2.WINDOW_NORMAL)
cv2.resizeWindow('image_selector_from_video', grid.window_width, grid.window_height)
# Read until video is completed
def image_grid(index, x_offset=0, y_offset=0, i=0):
cap.set(1, index)
recalculate_window_stuff()
# Resetting large image/grid to black each time.
l_img = np.zeros((grid.window_height, grid.window_width, 3), np.uint8)
cv2.imshow('image_selector_from_video', l_img)
cv2.waitKey(1)
index_for_frame_list = index
while i < grid.number_of_cells:
if __name__ == '__main__':
def get_color(x: int, y: int, img: np.ndarray) -> (int, int, int):
""" retrieve the b r g color values from the given image """
b, g, r, *_ = map(int, (*img[y, x], )) # change to int
return b, g, r
def on_click(event, x, y, flags, params):
""" when the image is clicked, set the hsv trackbars """
if event == cv.EVENT_LBUTTONUP:
b, g, r = get_color(x, y, params)
hsv.set_trackbars(b, g, r)
# make a resizable window
window_name = 'Image'
cv.namedWindow(window_name, cv.WINDOW_GUI_NORMAL)
image_file = "/some/path/to/image.png" # <- path to local image here
# create the window with the trackbars
hsv = HSVTrackbars()
hsv.tolerance = 5
while bool(cv.getWindowProperty(window_name, cv.WND_PROP_VISIBLE)):
try:
img = cv.imread(image_file)
img = hsv.apply_hsv(img)
# show the image
cv.imshow(window_name, img)
# click on the image to set the hsv values
leftCam.set(cv2.CAP_PROP_AUTO_EXPOSURE, 1)
rightCam.set(cv2.CAP_PROP_AUTO_EXPOSURE, 1)
leftCam.set(cv2.CAP_PROP_AUTO_WB, 0)
rightCam.set(cv2.CAP_PROP_AUTO_WB, 0)
def none(x):
pass
leftBrightness = "LeftBrightness"
rightBrightness = "RightBrightness"
leftExpo = "LeftExpo"
rightExpo = "RightExpo"
trackbarName = "Console"
cv2.namedWindow(trackbarName)
cv2.createTrackbar(leftBrightness, trackbarName, 0, 255, none)
cv2.createTrackbar(rightBrightness, trackbarName, 0, 255, none)
cv2.createTrackbar(leftExpo, trackbarName, 0, 5, none)
cv2.createTrackbar(rightExpo, trackbarName, 0, 5, none)
leftCam.set(cv2.CAP_PROP_AUTO_EXPOSURE, 1)
rightCam.set(cv2.CAP_PROP_AUTO_EXPOSURE, 1)
leftCam.set(cv2.CAP_PROP_FPS, 30)
rightCam.set(cv2.CAP_PROP_FPS, 30)
while True:
_, leftframe = leftCam.read()
_, rightframe = rightCam.read()
scipy.io.savemat(fileName + str(time) + '.mat', {'csvmatrix': matrix})
##### read fileName and tagSize#####
tagSize = float(input("Enter the tag Size: "))
fileName = input("Enter the file Name")
xTag = float(input("Input the x-coordinate in cm: "))
yTag = float(input("Input the y-coordinate in cm: "))
zTag = float(input("Input the z-coordinate in cm: "))
######## Location of tag ##############
tagLoc = np.array([-xTag / 100, yTag / 100, zTag / 100, 1])
# import rectangleArea as ra
cv2.namedWindow("preview")
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
################### Hard Coded calibration matrix for the calibration images in the image folder #########
mtx = np.array([[1.16853450e+03, 0.00000000e+00, 9.45814963e+02],
[0.00000000e+00, 1.15460499e+03, 5.37990908e+02],
[0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
dist = np.array([[
2.49754342e-01, -6.08282123e-01, -3.96471621e-04, 4.01400822e-03,
3.04199503e-01
]])
import tensorflow as tf
import numpy as np
import os
from cv2 import cv2
from PIL import Image
import config as cfg
import ImageProcessLib as imgLib
# ppt = imgLib.PPT()
cap = cv2.VideoCapture(0 + cv2.CAP_DSHOW)
cv2.namedWindow("segment")
with tf.Session() as sess:
"""读取模型"""
saver = tf.train.import_meta_graph('./My_Model/FCN_Model.meta')
saver.restore(sess, tf.train.latest_checkpoint('./My_Model'))
graph = tf.get_default_graph()
# for tensor_name in tf.contrib.graph_editor.get_tensors(tf.get_default_graph()):
# print(tensor_name)
img_PH = graph.get_tensor_by_name("img_PH:0")
batch_PH = graph.get_tensor_by_name("batch_PH:0")
drop_PH = graph.get_tensor_by_name("drop_PH:0")
output = graph.get_tensor_by_name("output:0")
"""识别和定位"""
while (1):
ret, srcIMG = cap.read()
rgbIMG = cv2.cvtColor(srcIMG, cv2.COLOR_BGR2RGB)
smallIMG = cv2.resize(rgbIMG,
(cfg.IMG_W, cfg.IMG_H)) # 网络输入图像大小224*160
image_4 = smallIMG[np.newaxis, :, :] # 扩展维度
image_n = imgLib.image_normalize(image_4) # 标准化
