def run_main():
# created a "threaded" video stream, allow the camera sensor to warmup
vs = PiVideoStream((640,480)).start()
time.sleep(2.0)
# read the first frame of the video
frame = vs.read()
# Set the ROI
c, r, w, h=200, 100, 70, 70
track_window=(c, r, w, h)
# Create mask and nomralized histogram
roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 30., 32.)), np.array((180.,255.,255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# Setup the termination criteria, either 80 iteration or move by atleast 1pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1)
while True:
frame = vs.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0,180], 1)
# apply meanshift to get the new location
ret, track_window = cv2.meanShift(dst, track_window, term_crit)
# apply camshift to get the new location
#ret, track_window = cv2.CamShift(dst, track_window, term_crit)
# draw it on image
x, y, w, h = track_window
cv2.rectangle(frame, (x, y), (x+w, y+h), 255, 2)
cv2.putText(frame, 'Tracked M', (x-25, y-10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2, cv2.LINE_AA)
cv2.imshow('Tracking', frame)
# if the 'q' key is pressed, break from the loop
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
vs.stop()
cv2.destroyAllWindows()
stream.close()
rawCapture.close()
camera.close()
# created a *threaded *video stream, allow the camera sensor to warmup,
# and start the FPS counter
print("[INFO] sampling THREADED frames from `picamera` module...")
vs = PiVideoStream().start()
time.sleep(2.0)
fps = FPS().start()
# loop over some frames...this time using the threaded stream
while fps._numFrames < args["num_frames"]:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
frame = imutils.resize(frame, width=400)
# check to see if the frame should be displayed to our screen
if args["display"] > 0:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# update the FPS counter
fps.update()
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
class emoElmo:
def __init__(self):
print("constructing emo elmo")
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
self.os = os
# Create the model
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu', input_shape=(48, 48, 1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
model.load_weights('model.h5')
self.model = model
self.cv2 = cv2
# prevents openCL usage and unnecessary logging messages
self.cv2.ocl.setUseOpenCL(False)
# dictionary which assigns each label an emotion (alphabetical order)
self.emotion_dict = {0: "Angry", 1: "Disgusted", 2: "Fearful",
3: "Happy", 4: "Neutral", 5: "Sad", 6: "Surprised"}
# dictionary to calculate total emotion score at the end of the run
self.emotion_score_dict = {"Angry": 0, "Disgusted": 0, "Fearful": 0,
"Happy": 0, "Neutral": 0, "Sad": 0, "Surprised": 0}
# get start datetime
self.startDateTime = datetime.now()
self.dateTimeString = self.startDateTime.strftime("%Y-%m-%d_%H:%M")
self.videoFileName = self.dateTimeString + '.avi'
self.audioFileName = self.dateTimeString + '.wav'
# initialize audio recording
self.form_1 = pyaudio.paInt16 # 16-bit resolution
self.chans = 1 # 1 channel
self.samp_rate = 44100 # 44.1kHz sampling rate
self.chunk = 4096 # 2^12 samples for buffer
# device index found by p.get_device_info_by_index(ii)
self.dev_index = 2
self.wav_output_filename = self.audioFileName # name of .wav file
self.audio = pyaudio.PyAudio() # create pyaudio instantiation
# create pyaudio stream
self.stream = self.audio.open(format=self.form_1, rate=self.samp_rate, channels=self.chans,
input_device_index=self.dev_index, input=True,
frames_per_buffer=self.chunk)
self.audioFrames = []
# start the webcam feed
self.vs = PiVideoStream().start()
time.sleep(2.0)
self.fps = FPS().start()
# define codec and create VideoWriter Object
self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.out = cv2.VideoWriter(self.videoFileName, self.fourcc, 30.0, (320, 240))
self.facecasc = cv2.CascadeClassifier(
'/home/pi/opencv/data/haarcascades/haarcascade_frontalface_default.xml')
self.wave = wave
# array to store all frames capture for post-processing
self.videoFrameStore = []
# boolean flag for recording
self.recording = 1
# tkinter settings
win = Tk()
win.title("Litmus Box")
win.geometry('800x480')
self.win = win
myFont = tkinter.font.Font(family='Helvetica', size=36, weight='bold')
self.stopRecordButton = Button(self.win, text = "STOP RECORD", font = myFont, command = lambda: self.stop_recording(), height = 2, width = 15)
self.stopRecordButton.pack(side = BOTTOM)
self.recordButton = Button(self.win, text = "RECORD", font = myFont, command = lambda: self.start_recording(), height = 2, width = 15)
self.recordButton.pack()
mainloop()
def start_recording(self):
print("call start recording")
self.recording = 1
while self.recording == 1:
# Find haar cascade to draw bounding box around face
print("inside whle loop")
frame = self.vs.read()
self.videoFrameStore.append(frame)
# fps stuff
self.out.write(frame)
self.fps.update()
# audio stuff
data = self.stream.read(self.chunk, exception_on_overflow=False)
self.audioFrames.append(data)
print("end of one iteration")
self.win.update()
print("exit while loop")
for currentVideoFrame in self.videoFrameStore:
# convert to gray and get face position
gray = self.cv2.cvtColor(currentVideoFrame, cv2.COLOR_BGR2GRAY)
faces = self.facecasc.detectMultiScale(
gray, scaleFactor=1.3, minNeighbors=5)
for (x, y, w, h) in faces:
roi_gray = gray[y:y + h, x:x + w]
cropped_img = np.expand_dims(np.expand_dims(
cv2.resize(roi_gray, (48, 48)), -1), 0)
prediction = self.model.predict(cropped_img)
maxindex = int(np.argmax(prediction))
# increment score
emotion = self.emotion_dict[maxindex]
self.emotion_score_dict[emotion] += 1
# write to audio file
self.stream.stop_stream()
self.stream.close()
self.audio.terminate()
self.fps.stop()
# save the audio frames as .wav file
wavefile = self.wave.open(self.wav_output_filename, 'wb')
wavefile.setnchannels(self.chans)
wavefile.setsampwidth(self.audio.get_sample_size(self.form_1))
wavefile.setframerate(self.samp_rate)
wavefile.writeframes(b''.join(self.audioFrames))
wavefile.close()
# write final emotion score to txt file
print(self.emotion_score_dict)
with open(self.dateTimeString + '.txt', 'w') as file:
file.write(json.dumps(self.emotion_score_dict))
print("[INFO] elasped time: {:.2f}".format(self.fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(self.fps.fps()))
# cap.release()
self.out.release()
self.cv2.destroyAllWindows()
self.vs.stop()
def stop_recording(self):
print("call stop record button")
self.recording = 0
def return_book():
Node1, Node2, Node3 = True, True, True
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
def node_status():
if Node1:
cv2.putText(frame, "NOT AVAILABLE", (LEFT_R_outside),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
if Node2:
cv2.putText(frame, "NOT AVAILABLE", (CENTER_R_outside),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
if Node3:
cv2.putText(frame, "NOT AVAILABLE", (RIGHT_R_outside),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
frame_rate_calc = 1
freq = cv2.getTickFrequency()
global frame
vs = PiVideoStream().start()
time.sleep(2.0)
with detection_graph.as_default():
with tf.Session() as sess:
while True:
frame = vs.read()
frame = imutils.resize(frame, width=400)
t1 = cv2.getTickCount()
cv2.putText(frame, "FPS: {0:.2f}".format(frame_rate_calc),
(30, 50), font, 1, (255, 255, 0), 2, cv2.LINE_AA)
t2 = cv2.getTickCount()
time1 = (t2 - t1) / freq
frame_rate_calc = 1 / time1
frame_expanded = np.expand_dims(frame, axis=0)
(boxes, scores, classes,
num) = sess.run([
detection_boxes, detection_scores, detection_classes,
num_detections
],
feed_dict={image_tensor: frame_expanded})
vis_util.visualize_boxes_and_labels_on_image_array(
frame,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=5,
min_score_thresh=min_t_hold
#min_score_thresh=0.38
)
cv2.rectangle(frame, RIGHT_L_outside, RIGHT_R_outside,
(255, 255, 255), 1)
cv2.rectangle(frame, CENTER_L_outside, CENTER_R_outside,
(255, 255, 255), 1)
cv2.rectangle(frame, LEFT_L_outside, LEFT_R_outside,
(255, 255, 255), 1)
try:
for i, b in enumerate(boxes[0]):
if classes[0][i] == 1: # if book
# if scores[0][i] > 0.5:
if scores[0][i] > min_t_hold:
ymin = boxes[0][i][0]
xmin = boxes[0][i][1]
ymax = boxes[0][i][2]
xmax = boxes[0][i][3]
width = int(((xmin + xmax / 2) * IM_WIDTH))
height = int(((ymin + ymax / 2) * IM_HEIGHT))
mid_x = (xmax + xmin) / 2 # in percentage
mid_y = (ymax + ymin) / 2 # in percentage
mid_x_pixel = int(mid_x * IM_WIDTH)
mid_y_pixel = int(mid_y * IM_HEIGHT)
apx_distance = round((1 - (xmax - xmin))**4, 1)
centers.append((mid_x_pixel, mid_y_pixel))
# cv2.putText(frame, '{}'.format(apx_distance), (mid_x_pixel,mid_y_pixel), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
cv2.circle(frame, (mid_x_pixel, mid_y_pixel),
2, (255, 0, 0))
# if apx_distance <= 0.5:
if apx_distance <= 0.9: # change to 0.5 ^
cv2.putText(
frame, "CLOSE",
(mid_x_pixel - 50, mid_y_pixel - 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(244, 66, 137), 2)
if mid_x > 0.6 and mid_x < 0.95:
cv2.putText(
frame, "RIGHT",
(mid_x_pixel - 50, mid_y_pixel),
cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(66, 244, 128), 2)
Node3_Frame[
1] += 1 # 1 is True 0 is False
if Node3_Frame[
1] >= Node_Frame_Wait_Time:
Node3 = True
N3 = 1
Node3_Frame[1] = 0
elif (mid_x > 0.6
and mid_x < 0.95) == False:
Node3_Frame[
0] += 1 # 1 is True 0 is False
if Node3_Frame[
0] >= Node_Frame_Wait_Time:
Node3 = False
N3 = 0
Node3_Frame[0] = 0
else:
Node3 = None
if mid_x > 0.32 and mid_x < 0.58:
cv2.putText(
frame, "CENTER",
(mid_x_pixel - 50, mid_y_pixel),
cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(66, 244, 128), 2)
Node2_Frame[
1] += 1 # 1 is True 0 is False
if Node2_Frame[
1] >= Node_Frame_Wait_Time:
Node2 = True
N2 = 1
Node2_Frame[1] = 0
elif (mid_x > 0.32
and mid_x < 0.58) == False:
Node2_Frame[0] += 1
if Node2_Frame[
0] >= Node_Frame_Wait_Time:
Node2 = False
N2 = 0
Node2_Frame[0] = 0
else:
Node2 = None
if mid_x > 0.05 and mid_x < 0.3:
cv2.putText(
frame, "LEFT",
(mid_x_pixel - 50, mid_y_pixel),
cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(66, 244, 128), 2)
Node1_Frame[
1] += 1 # 1 is True 0 is False
if Node1_Frame[
1] >= Node_Frame_Wait_Time:
Node1 = True
N1 = 1
Node1_Frame[1] = 0
elif (mid_x > 0.05
and mid_x < 0.3) == False:
Node1_Frame[0] += 1
if Node1_Frame[
0] >= Node_Frame_Wait_Time:
Node1 = False
N1 = 0
Node1_Frame[0] = 0
else:
Node1 = None
# led_test()
node_status()
if (len(centers)) >= 2:
recentX = 0
recentY = 1
center_size = len(centers)
for i in range(0, center_size - 1):
# cv2.line(frame, (centers[i]), (centers[i+1]), (0, 255, 0), 2) # for connecting books
distance = np.linalg.norm(
int(mid_x_pixel +
(mid_x_pixel + IM_HEIGHT)) / 2 -
int(mid_y_pixel +
(mid_y_pixel + IM_WIDTH)) / 2)
distance_cm = distance / 12
lengths.append(
(distance, centers[i], centers[i + 1]
)) # lenght point A and point B
if len(
lengths
) >= 2: # to find the biggest distance and draw a line between
if lengths[i][0] < lengths[i + 1][
0] and lengths[i][0] < lengths[
i +
1][0]: # 321< 400 305 < 359
CURRENT_SPACE.append(lengths[i +
1])
else:
CURRENT_SPACE.append(lengths[i])
recentPointMax = 0
cv2.line(
frame,
(CURRENT_SPACE[recentPointMax][1]),
(CURRENT_SPACE[recentPointMax][2]),
(255, 255, 255), 2)
cv2.putText(
frame,
str(CURRENT_SPACE[recentPointMax]
[0]),
(mid_x_pixel, mid_y_pixel),
cv2.FONT_HERSHEY_SIMPLEX, 2,
(255, 255, 255), 3)
MAX_SPACE.append(
CURRENT_SPACE[recentPointMax])
print(
" max distance " +
str(MAX_SPACE[recentPointMax][0]) +
" wot " +
str(MAX_SPACE[recentPointMax][1]) +
" wot " +
str(MAX_SPACE[recentPointMax][2]))
print(MAX_SPACE[recentPointMax][1][0])
CURRENT_SPACE.clear()
lengths.clear()
# centers.clear()
# print(lengths)
recentX += 1
recentY += 1
centers.clear()
# node_status()
# print("break")
except Exception as e:
print(e)
traceback.print_exc()
# cv2.imshow('object detection', cv2.resize(frame, (800, 480)))
cv2.imshow('object detection', frame)
# cv2.waitKey(250)
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
vs.stop()
break
class Camera():
def __init__(self, config={}):
self.config = config
self.flip = self.config['flip_cam']
self.frame_width = self.config['res_x']
self.frame_height = self.config['res_y']
if not isLoadPiCam:
self.cap = cv2.VideoCapture(0)
# getting width and height from the capture device
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.frame_width)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.frame_height)
else:
self.cap = PiVideoStream(resolution=(
self.frame_width, self.frame_height)).start()
self.canRecord = True
self.timeWithoutBody = 0
self.startRecordingTime = 0
self.pauseRecording = 0
# self.fourcc = 0x00000021
self.fourcc = cv2.VideoWriter_fourcc(*'avc1')
self.out = cv2.VideoWriter()
self.maxRecordingTime = self.config['max_record_time']
self.classifier = cv2.CascadeClassifier(self.config['classifier'])
self.isRecording = False
self.currentFrame = None
def recording(self):
if isLoadPiCam is False:
_, img = self.cap.read()
else:
img = self.cap.read()
if self.flip:
img = cv2.flip(img, 0)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = resize(gray, int(self.frame_width / 2),
int(self.frame_height / 2))
self.isRecording = self.out.isOpened()
objects = self.classifier.detectMultiScale(gray,
scaleFactor=1.3,
minNeighbors=5,
minSize=(30, 30))
rects = np.array([[x, y, x + w, y + h]
for (x, y, w, h) in objects])
filtered = non_max_suppression(rects, overlapThresh=0.65)
for (x1, y1, x2, y2) in filtered:
cv2.rectangle(img, (x1 * 2, y1 * 2), (x2 * 2, y2 * 2),
(0, 255, 0), 1)
if not self.out.isOpened() and self.canRecord:
print('starting recording')
self.startRecordingTime = GetMilliSecs(time.time())
self.pauseRecording = 0
filename = self.config['video_folder'] + \
GetTimeStamp(time) + '.mp4'
res = self.out.open(filename,
self.fourcc,
20,
(self.frame_width, self.frame_height))
if self.out.isOpened():
self.out.write(img)
if (self.startRecordingTime +
self.maxRecordingTime) < GetMilliSecs(time.time()):
self.out.release()
self.canRecord = False
self.pauseRecording = GetMilliSecs(time.time())
print('Stopped recording')
if not self.canRecord and (self.pauseRecording +
self.config['time_in_between'] <
GetMilliSecs(time.time())):
self.canRecord = True
self.currentFrame = img
def get_frame(self):
if self.currentFrame is None:
if isLoadPiCam is False:
_, self.currentFrame = self.cap.read()
else:
self.currentFrame = self.cap.read()
_, jpeg = cv2.imencode('.jpg', self.currentFrame)
return jpeg.tobytes()
def __del__(self):
try:
self.cap.release()
cv2.destroyAllWindows()
except:
pass
net = cv.dnn.readNet('human-pose-estimation-0001.xml',
'human-pose-estimation-0001.bin')
# Specify target device.
net.setPreferableTarget(cv.dnn.DNN_TARGET_MYRIAD)
# starting video streaming
cv.namedWindow('pose')
vs = PiVideoStream().start()
time.sleep(2.0)
joint = 0
chestY = 0
while True:
startTime = time.time()
frameArray = vs.read()
captureTime = time.time()
frameClone = imutils.resize(frameArray, width=456)
blob = cv.dnn.blobFromImage(frameArray, size=(456, 256), ddepth=cv.CV_8U)
prepareTime = time.time()
net.setInput(blob)
heatmap = net.forward()
processTime = time.time()
rightShoulder = False
leftShoulder = False
chest = False
rightShoulderX = 0
rightShoulderY = 0
leftShoulderX = 0
leftShoulderY = 0
def cameraOptim():
time.sleep(2)
serialHandler = SerialHandler.SerialHandler("/dev/ttyACM0")
serialHandler.startReadThread()
serialHandler.sendPidActivation(True)
def moveForward():
serialHandler.sendMove(SPEED, -1.8)
print("Forward")
def moveLeft():
serialHandler.sendMove(SPEED, -23.0)
print("Left")
def moveRight():
serialHandler.sendMove(SPEED, 23.0)
print("Right")
def moveBackward():
serialHandler.sendMove(-SPEED, -1.8)
print("Back")
def dontMove():
serialHandler.sendMove(0, -1.8)
print("Break")
def avoidObstacle():
dontMove()
time.sleep(0.1)
moveBackward()
time.sleep(1)
moveLeft()
time.sleep(1)
moveForward()
time.sleep(0.2)
moveRight()
time.sleep(1)
moveForward()
def region_of_interest(img, vertices):
# Define a blank matrix that matches the image height/width.
mask = np.zeros_like(img)
# Retrieve the number of color channels of the image.
#channel_count = img.shape[2]
# Create a match color with the same color channel counts.
match_mask_color = (255)
# Fill inside the polygon
cv2.fillPoly(mask, vertices, match_mask_color)
# Returning the image only where mask pixels match
masked_image = cv2.bitwise_and(img, mask)
return masked_image
def draw_lanes(img, lines, color=[0, 255, 255], thickness=3):
# if this fails, go with some default line
try:
# finds the maximum y value for a lane marker
# (since we cannot assume the horizon will always be at the same point.)
ys = []
for i in lines:
for ii in i:
ys += [ii[1], ii[3]]
min_y = min(ys)
max_y = 600
new_lines = []
line_dict = {}
for idx, i in enumerate(lines):
for xyxy in i:
# These four lines:
# modified from http://stackoverflow.com/questions/21565994/method-to-return-the-equation-of-a-straight-line-given-two-points
# Used to calculate the definition of a line, given two sets of coords.
x_coords = (xyxy[0], xyxy[2])
y_coords = (xyxy[1], xyxy[3])
A = vstack([x_coords, ones(len(x_coords))]).T
m, b = lstsq(A, y_coords)[0]
# Calculating our new, and improved, xs
x1 = (min_y - b) / m
x2 = (max_y - b) / m
line_dict[idx] = [m, b, [int(x1), min_y, int(x2), max_y]]
new_lines.append([int(x1), min_y, int(x2), max_y])
final_lanes = {}
for idx in line_dict:
final_lanes_copy = final_lanes.copy()
m = line_dict[idx][0]
b = line_dict[idx][1]
line = line_dict[idx][2]
if len(final_lanes) == 0:
final_lanes[m] = [[m, b, line]]
else:
found_copy = False
for other_ms in final_lanes_copy:
if not found_copy:
if abs(other_ms * 1.2) > abs(m) > abs(
other_ms * 0.8):
if abs(final_lanes_copy[other_ms][0][1] *
1.2) > abs(b) > abs(
final_lanes_copy[other_ms][0][1] *
0.8):
final_lanes[other_ms].append([m, b, line])
found_copy = True
break
else:
final_lanes[m] = [[m, b, line]]
line_counter = {}
for lanes in final_lanes:
line_counter[lanes] = len(final_lanes[lanes])
top_lanes = sorted(line_counter.items(),
key=lambda item: item[1])[::-1][:2]
lane1_id = top_lanes[0][0]
lane2_id = top_lanes[1][0]
def average_lane(lane_data):
x1s = []
y1s = []
x2s = []
y2s = []
for data in lane_data:
x1s.append(data[2][0])
y1s.append(data[2][1])
x2s.append(data[2][2])
y2s.append(data[2][3])
return int(mean(x1s)), int(mean(y1s)), int(mean(x2s)), int(
mean(y2s))
l1_x1, l1_y1, l1_x2, l1_y2 = average_lane(final_lanes[lane1_id])
l2_x1, l2_y1, l2_x2, l2_y2 = average_lane(final_lanes[lane2_id])
return [l1_x1, l1_y1, l1_x2, l1_y2], [l2_x1, l2_y1, l2_x2,
l2_y2], lane1_id, lane2_id
except Exception as e:
print(str(e))
def process_img(image):
original_image = image
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
processed_img = cv2.Canny(gray_image, 200, 300)
processed_img = cv2.GaussianBlur(processed_img, (5, 5), 0)
#processed_img = gray_image
vertices = np.array([
[10, 500],
[10, 400],
[300, 250],
[500, 250],
[800, 500],
[800, 500],
], np.int32)
cropped_image = region_of_interest(processed_img, [vertices])
lines = cv2.HoughLinesP(cropped_image,
rho=1,
theta=np.pi / 180,
threshold=180,
lines=np.array([]),
minLineLength=20,
maxLineGap=15)
m1 = 0
m2 = 0
try:
l1, l2, m1, m2 = draw_lanes(original_image, lines)
cv2.line(original_image, (l1[0], l1[1]), (l1[2], l1[3]),
[0, 255, 0], 30)
cv2.line(original_image, (l2[0], l2[1]), (l2[2], l2[3]),
[0, 255, 0], 30)
except Exception as e:
print(str(e))
pass
try:
for coords in lines:
coords = coords[0]
try:
cv2.line(processed_img, (coords[0], coords[1]),
(coords[2], coords[3]), [255, 0, 0], 3)
except Exception as e:
print(str(e))
except Exception as e:
pass
#line_image = draw_lines(image, lines, thickness=1)
#line_image = image
#return line_image
return processed_img, original_image, m1, m2
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-n",
"--num-frames",
type=int,
default=100,
help="# of frames to loop over for FPS test")
ap.add_argument("-d",
"--display",
type=int,
default=1,
help="Whether or not frames should be displayed")
args = vars(ap.parse_args())
# initialize the camera and stream
#camera = PiCamera()
#camera.resolution = (800, 600)
#camera.framerate = 32
#last_time = time.time()
# created a *threaded *video stream, allow the camera sensor to warmup,
# and start the FPS counter
print("[INFO] sampling THREADED frames from `picamera` module...")
vs = PiVideoStream().start()
time.sleep(2.0)
#fps = FPS().start()
# loop over some frames...this time using the threaded stream
#while fps._numFrames < args["num_frames"]:
# do a bit of cleanup
last_time = time.time()
while (True):
#rawCapture=PiRGBArray(camera, size=(800,600))
#cap.framerate = 10
#camera.capture(rawCapture, format="bgr")
frame = vs.read()
frame = imutils.resize(frame, width=800)
last_time = time.time()
new_screen, original_image, m1, m2 = process_img(frame)
#rawCapture = PiRGBArray(camera, size=(320, 240))
#stream = camera.capture_continuous(rawCapture, format="bgr",
#use_video_port=True)
#frame = stream.array
#screen= process_img(frame)
print('Frame took {} seconds'.format(time.time() - last_time))
cv2.imshow(
'frame',
original_image) #se mai poate adauga argumentul cv2.COLOR_BGR2RGB
if (waitline != ser.readline()):
if m1 < 0 and m2 < 0:
moveRight()
time.sleep(0.1)
dontMove()
elif m1 > 0 and m2 > 0:
moveLeft()
time.sleep(0.1)
dontMove()
else:
moveForward()
time.sleep(0.1)
dontMove()
else:
print("OBSTACLE AHEAD")
avoidObstacle()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
vs.stop()
def cameraOptim():
def region_of_interest(img, vertices):
# Define a blank matrix that matches the image height/width.
mask = np.zeros_like(img)
# Retrieve the number of color channels of the image.
#channel_count = img.shape[2]
# Create a match color with the same color channel counts.
match_mask_color = (255)
# Fill inside the polygon
cv2.fillPoly(mask, vertices, match_mask_color)
# Returning the image only where mask pixels match
masked_image = cv2.bitwise_and(img, mask)
return masked_image
def draw_lines(img, lines, color=[255, 0, 0], thickness=10):
if lines is None:
return img
line_img = np.zeros(
(img.shape[0], img.shape[1], 3),
dtype=np.uint8,
)
# Loop over all lines and draw them on the blank image.
for line in lines:
for x1, y1, x2, y2 in line:
cv2.line(line_img, (x1, y1), (x2, y2), color, thickness)
# Merge the image with the lines onto the original.
img = cv2.addWeighted(img, 0.8, line_img, 1.0, 0.0)
# Return the modified image.
return img
def process_img(image):
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
processed_img = cv2.Canny(gray_image, 200, 300)
#processed_img = gray_image
vertices = np.array([
[10, 500],
[10, 400],
[300, 250],
[500, 250],
[800, 500],
[800, 500],
], np.int32)
cropped_image = region_of_interest(processed_img,
np.array([vertices], np.int32))
lines = cv2.HoughLinesP(cropped_image,
rho=2,
theta=np.pi / 180,
threshold=40,
lines=np.array([]),
minLineLength=10,
maxLineGap=110)
line_image = draw_lines(image, lines, thickness=1)
#line_image = image
return line_image
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-n",
"--num-frames",
type=int,
default=100,
help="# of frames to loop over for FPS test")
ap.add_argument("-d",
"--display",
type=int,
default=1,
help="Whether or not frames should be displayed")
args = vars(ap.parse_args())
# initialize the camera and stream
#camera = PiCamera()
#camera.resolution = (800, 600)
#camera.framerate = 32
last_time = time.time()
'''
while (True):
rawCapture=PiRGBArray(camera, size=(800,600))
#cap.framerate = 10
camera.capture(rawCapture, format="bgr")
frame=rawCapture.array
#rawCapture = PiRGBArray(camera, size=(320, 240))
#stream = camera.capture_continuous(rawCapture, format="bgr",
#use_video_port=True)
#frame = stream.array
screen= process_img(frame)
print('Frame took {} seconds'.format(time.time()-last_time))
last_time = time.time()
cv2.imshow('frame', screen)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
#cap.release()
cv2.destroyAllWindows()
'''
'''
# allow the camera to warmup and start the FPS counter
print("[INFO] sampling frames from `picamera` module...")
time.sleep(2.0)
fps = FPS().start()
# loop over some frames
for (i, f) in enumerate(stream):
# grab the frame from the stream and resize it to have a maximum
# width of 400 pixels
frame = f.array
frame = imutils.resize(frame, width=400)
# check to see if the frame should be displayed to our screen
if args["display"] > 0:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# clear the stream in preparation for the next frame and update
# the FPS counter
rawCapture.truncate(0)
fps.update()
# check to see if the desired number of frames have been reached
if i == args["num_frames"]:
break
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# do a bit of cleanup
cv2.destroyAllWindows()
stream.close()
rawCapture.close()
camera.close()
'''
# created a *threaded *video stream, allow the camera sensor to warmup,
# and start the FPS counter
print("[INFO] sampling THREADED frames from `picamera` module...")
vs = PiVideoStream().start()
time.sleep(2.0)
#fps = FPS().start()
# loop over some frames...this time using the threaded stream
#while fps._numFrames < args["num_frames"]:
'''
while(True)
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 800 pixels
frame = vs.read()
frame = imutils.resize(frame, width=800)
# check to see if the frame should be displayed to our screen
if args["display"] > 0:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# update the FPS counter
fps.update()
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
'''
# do a bit of cleanup
while (True):
#rawCapture=PiRGBArray(camera, size=(800,600))
#cap.framerate = 10
#camera.capture(rawCapture, format="bgr")
frame = vs.read()
frame = imutils.resize(frame, width=800)
#rawCapture = PiRGBArray(camera, size=(320, 240))
#stream = camera.capture_continuous(rawCapture, format="bgr",
#use_video_port=True)
#frame = stream.array
screen = process_img(frame)
print('Frame took {} seconds'.format(time.time() - last_time))
last_time = time.time()
cv2.imshow('frame', screen)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
vs.stop()
class PeopleCounter(object):
def __init__(self, flip=True):
self.vs = PiVideoStream(resolution=(800, 608)).start()
self.flip = flip
time.sleep(2.0)
self.firstFrame = None
self.move_time = time.time()
self.movelist = []
self.enter = 0
self.leave = 0
def __del__(self):
self.vs.stop()
def crossed_y_centerline(self, enter, leave, movelist):
# Check if over center line then count
if len(movelist) > 1: # Are there two entries
if ( movelist[0] <= y_center
and movelist[-1] > y_center + y_buf ):
leave += 1
movelist = []
elif ( movelist[0] > y_center
and movelist[-1] < y_center - y_buf ):
enter += 1
movelist = []
return enter, leave, movelist
def flip_if_needed(self, frame):
if self.flip:
return np.flip(frame, 0)
return frame
def get_frame(self):
frame = self.flip_if_needed(self.vs.read())
frame = self.process_image(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
def process_image(self, frame):
motion_found = False
biggest_area = MIN_AREA
frame = imutils.resize(frame, width=min(800, frame.shape[1]))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if self.firstFrame is None:
self.firstFrame = gray
return frame
cv2.line( frame,( 0, y_center ),( x_max, y_center ),(255, 0, 0), 2 )
frameDelta = cv2.absdiff(self.firstFrame, gray)
thresh = cv2.threshold(frameDelta, 70, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
(cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if cnts:
for c in cnts:
if cv2.contourArea(c) < 700:
continue
found_area = cv2.contourArea(c)
if found_area > biggest_area:
motion_found = True
biggest_area = found_area
(x, y, w, h) = cv2.boundingRect(c)
cx = int(x + w/2)
cy = int(y + h/2)
cw, ch = w, h
if motion_found:
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.circle(frame, (cx, cy), 5, (0, 0, 255), 2)
move_timer = time.time() - self.move_time
if (move_timer >= movelist_timeout):
self.movelist = []
self.move_time = time.time()
old_enter = self.enter
old_leave = self.leave
self.movelist.append(cy)
self.enter, self.leave, self.movelist = self.crossed_y_centerline(self.enter, self.leave, self.movelist)
if not self.movelist:
if self.enter > old_enter:
prefix = 'enter'
elif self.leave > old_leave:
prefix = 'leave'
else:
prefix = 'error'
img_text = ("LEAVE %i : ENTER %i" % (self.enter, self.leave))
cv2.putText(frame, img_text, (45, 25), font, 1.0, (0, 0, 255), 2)
return frame
src = np.array([[15, 226], [303, 221], [262, 2], [64, 5]], dtype="float32")
dst = np.array([[50, 240], [270, 240], [270, 0], [50, 0]], dtype="float32")
M = cv2.getPerspectiveTransform(src, dst)
image_hsv = None
pixel = (0, 0, 0) #RANDOM DEFAULT VALUE
try:
arduino = serial.Serial('/dev/ttyUSB0', baudrate=9600, timeout=3.0)
except:
arduino = serial.Serial('/dev/ttyUSB1', baudrate=9600, timeout=3.0)
#video = cv2.VideoCapture(0)
video = PiVideoStream(resolution=(640, 480), framerate=60).start()
time.sleep(2.0)
timeCheck = time.time()
while True:
image_src = video.read()
image_src = cv2.flip(image_src, -1)
################# color transformation and filter -------> binary image
image_hsv = cv2.cvtColor(image_src, cv2.COLOR_BGR2HSV)
image_mask = cv2.inRange(image_hsv, lower1, upper1) + cv2.inRange(
image_hsv, lower2, upper2)
############################ warp tranform ------------> birds eye view
warped = cv2.warpPerspective(image_mask, M, (320, 240))
#cv2.imshow("aaa", warped)
#cv2.waitKey(1)
############ for line detection
edges = cv2.Canny(warped, 30, 50)
section = 100
roi = edges[section:, :]
def process(self):
self.image = tf.placeholder(tf.float32, shape=[1, self.width, self.height, 3],name='image')
x = self.image
rate = [1,1]
buff = []
with tf.variable_scope(None, 'MobilenetV1'):
for m in self.layers:
strinde = [1,m['stride'],m['stride'],1]
rate = [m['rate'],m['rate']]
if (m['convType'] == "conv2d"):
x = self.conv(x,strinde,m['blockId'])
buff.append(x)
elif (m['convType'] == "separableConv"):
x = self.separableConv(x,strinde,m['blockId'],rate)
buff.append(x)
self.heatmaps = self.convToOutput(x, 'heatmap_2')
self.offsets = self.convToOutput(x, 'offset_2')
self.displacementFwd = self.convToOutput(x, 'displacement_fwd_2')
self.displacementBwd = self.convToOutput(x, 'displacement_bwd_2')
self.heatmaps = tf.sigmoid(self.heatmaps, 'heatmap')
cap = PiVideoStream().start()
time.sleep(2.0)
cap_width = 320
cap_height = 240
width_factor = cap_width/self.width
height_factor = cap_height/self.height
with tf.Session() as sess:
######################
# Setup GCloud #
######################
project_id = "ai-dj-36"
topic_name = "pose"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_name)
# create topic if it does not exists
project_path = publisher.project_path(project_id)
topics = publisher.list_topics(project_path)
topic_names = [topic.name for topic in topics]
if topic_path not in topic_names:
topic = publisher.create_topic(topic_path)
print('Topic created: {}'.format(topic))
# continue with model
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver()
save_dir = './checkpoints'
save_path = os.path.join(save_dir, 'model_ckpt')
saver.save(sess, save_path)
while True:
total_point_var = 0.0
ave_counter = 0
frame = cap.read()
init_pose = self.process_frame(sess, cap, frame, width_factor, height_factor)
while(len(init_pose) <= 0 or init_pose[0]['score'] <= 0.2):
frame = cap.read()
init_pose = self.process_frame(sess, cap, frame, width_factor, height_factor)
cv2.imshow("1", frame)
cv2.waitKey(1)
while True:
frame = cap.read()
orig_image = frame
startime = time.time()
curr_pose = self.process_frame(sess, cap, frame, width_factor, height_factor)
if len(curr_pose) == 0:
continue
if ave_counter < NUM_FRAMES_TO_AVERAGE:
total_point_var += measure_keypoint_var(init_pose[0], curr_pose[0])
ave_counter += 1
else:
print(total_point_var / NUM_FRAMES_TO_AVERAGE)
# send score to appengine
curtime = time.time()
payload_contents = {"device_id":"jeffsrpi", "published_at":curtime, "pose": total_point_var / NUM_FRAMES_TO_AVERAGE}
payload = json.dumps(payload_contents)
payload = payload.encode("utf-8")
print(payload_contents)
future = publisher.publish(topic_path, data=payload)
ave_counter = 0
total_point_var = 0
init_pose = curr_pose
for idx in range(len(curr_pose)):
if curr_pose[idx]['score'] > 0.2:
color = color_table[idx]
drawKeypoints(curr_pose[idx], orig_image, color)
drawSkeleton(curr_pose[idx], orig_image)
endtime = time.time()
print('Time cost per frame : %f' % (endtime - startime))
cv2.imshow("1", orig_image)
cv2.waitKey(1)
class VideoCamera(object):
def __init__(self):
self.cap = PiVideoStream().start()
time.sleep(0.1)
print("Initialising Raspberry Pi...")
GPIO.output(11, 1)
print("LED Red Testing")
time.sleep(1.0)
GPIO.output(11, 0)
GPIO.output(13, 1)
print("LED Green Testing")
time.sleep(1.0)
GPIO.output(13, 0)
GPIO.output(15, 1)
print("LED Blue Testing")
time.sleep(1.0)
GPIO.output(15, 0)
wiringpi.wiringPiSetup()
wiringpi.pinMode(26, 2)
wiringpi.softPwmCreate(26, 0, 25)
def __del__(self):
self.cap.stop()
def get_frame(self):
frame = self.cap.read()
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
def get_object(self, classifier):
frame = self.cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
objects = classifier.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
# Draw a rectangle around the objects
for (x, y, w, h) in objects:
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 140, 125), 2)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
def get_mask(self):
frame = self.cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
dutycycle = 0
model = Model()
interpreter = model.load_interpreter()
input_details = model.input_details()
output_details = model.output_details()
input_shape = input_details[0]['shape']
label_dict = {0: 'MASK', 1: "NO MASK"}
eye_img = gray
resized = cv2.resize(eye_img, (100, 100))
normalized = resized / 255.0
reshaped = np.reshape(normalized, input_shape)
reshaped = np.float32(reshaped)
interpreter.set_tensor(input_details[0]['index'], reshaped)
interpreter.invoke()
result = interpreter.get_tensor(output_details[0]['index'])
result = 1 - result
label = np.argmax(result, axis=1)[0]
if label == 0:
cv2.putText(frame, label_dict[label], (75, 150),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (250, 240, 255), 2)
GPIO.output(15, 1)
print(label_dict[label])
wiringpi.softPwmWrite(26, 25)
time.sleep(0.1)
position = dutycycle
GPIO.output(15, 0)
elif label == 1:
cv2.putText(frame, label_dict[label], (75, 150),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (250, 240, 255), 2)
GPIO.output(13, 1)
print(label_dict[label])
wiringpi.softPwmWrite(26, 0)
time.sleep(0.1)
position = dutycycle
GPIO.output(13, 0)
ret, jpeg = cv2.imencode('.jpg', frame)
return frame
def run(self):
while True:
start_time = time.time()
#time.sleep(60) #Because of at startup nothing is connected yet
#Try to find every Pico Zebro every 60 Seconds
#First Send global command to all Pico Zebro with Stop.
#Wait untill connected Pico Zebro's give back yes I am stopped
#Also Turn all leds off.
#if within Time not every one has stopped Try sending global
#command again.
#Picture(1)
time1=0
t_start = time.time() # start
e1 = cv2.getTickCount()
#First Take original Picture
vs = PiVideoStream().start()
#time.sleep(2.0)
fps = FPS().start()
while fps._numFrames < 10:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
# check to see if the frame should be displayed to our screen
# cv2.imshow("Frame", frame)
cv2.imwrite("image25.jpg",frame)
key = cv2.waitKey(1) & 0xFF
# update the FPS counter
fps.update()
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# do a bit of cleanup
cv2.destroyWindow("Frame")
vs.stop()
Original = cv2.imread("Image1.jpg")
e2 = cv2.getTickCount()
#With 1 Vor image1 being original image where nothing has moved
time1 = (e2 - e1) / cv2.getTickFrequency() + time1
elapsedTime = time.time()-t_start
print (time1, elapsedTime)
#for Devices in 16:
#print(Devices)
#if Devices == 1: # This has to be done for every Zebro
# Also if Devices is 1 give a value the address of Pico Zebro 1.
#Say Pico Zebro 1 Turn led 1 on.
#Wait until said back in register it is turned on for certain time
#Picture(2) #led 1 on picture 2
#Say Pico Zebro 1 Turn led 1 off and 3 on.
#wait until Pico Zebro Says Yeah have done that
#Picture(3) #led 3 on in picture 3
# Turn All leds of again. # Till here other things needs to be coded for every possible
Led_1 = cv2.imread("Image2.jpg")
Led_3 = cv2.imread("Image3.jpg")
picture_test = 0
New_image_Led_1 = abs(Original - Led_1) #Taking away improved time with 0.05 seconds which is fo 20 zebros: 1 second
New_image_Led_3 = abs(Original - Led_3)
Difference_led_1 = Image_Difference(New_image_Led_1)
Difference_led_3 = Image_Difference(New_image_Led_3)
Finding_Canny_Led_1 = cv2.Canny(Difference_led_1, 15, 200)
Finding_Canny_Led_3 = cv2.Canny(Difference_led_3, 15, 200)
Finding_Canny_Led_1 = cv2.morphologyEx(Finding_Canny_Led_1, cv2.MORPH_CLOSE, np.ones((8,8),np.uint8))
Finding_Canny_Led_3 = cv2.morphologyEx(Finding_Canny_Led_3, cv2.MORPH_CLOSE, np.ones((8,8),np.uint8))
Finding_Canny_Led_1 = cv2.Canny(Finding_Canny_Led_1, 100, 200)
Finding_Canny_Led_3 = cv2.Canny(Finding_Canny_Led_3, 100, 200)
(_, contours_Led_1, _) = cv2.findContours(Finding_Canny_Led_1.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
(_, contours_Led_3, _) = cv2.findContours(Finding_Canny_Led_3.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
x_Led_1 = 0
y_Led_1 = 0
w_Led_1 = 0
h_Led_1 = 0
for c in contours_Led_1:
try:
[x_Led_1,y_Led_1,w_Led_1,h_Led_1] = cv2.boundingRect(c)
cv2.rectangle(Difference_led_1,(x_Led_1,y_Led_1),(x_Led_1+w_Led_1,y_Led_1+h_Led_1),(0,255,0),2)
cv2.putText(Difference_led_1,'Found led 1',(x_Led_1+w_Led_1+10,y_Led_1+h_Led_1),0,0.3,(0,255,0))
except AttributeError:
print("Nothing Found")
pass
x_Led_3 = 0
y_Led_3 = 0
w_Led_3 = 0
h_Led_3 = 0
for c in contours_Led_3:
try:
[x_Led_3,y_Led_3,w_Led_3,h_Led_3] = cv2.boundingRect(c)
cv2.rectangle(Difference_led_3,(x_Led_3,y_Led_3),(x_Led_3+w_Led_3,y_Led_3+h_Led_3),(0,255,0),2)
cv2.putText(Difference_led_3,'Found led 3',(x_Led_3+w_Led_3+10,y_Led_3+h_Led_3),0,0.3,(0,255,0))
except AttributeError:
print("Nothing Found")
pass
#For some reason this debug functions gives errors that kille
#everything which is anoying
#Add led 1 and 3 together for Testing purposes
#LEDS_Image = cv2.addWeighted(Difference_led_1,1,Difference_led_3,1,0)
#cv2.imwrite("Leds_image.jpg", LEDS_Image)
#cv2.imshow("LEds together", LEDS_Image)
try:
(Zebro_Middle_x,Zebro_Middle_y,Direction) = Find_Orientation(x_Led_1,x_Led_3,y_Led_1,y_Led_3)
#print(Zebro_Middle_x,Zebro_Middle_y,Direction)
except TypeError as e:
print(e)
pass
#if Devices == 0: in here it is multiple times aquire
#set data from PZ 1
#Zebro_1_Middle_x = Zebro_Middle_x
#Zebro_1_Middle_y,
#Direction_Zebro_1 = Direction
#etc every value
#Now Add To a Value 1- (amount of Robots) These 3 Values and Send it to the thread which
#Has the control of the Robots
#once every value for every possible Zebro is determind then
#Check if any of the x and y values are close to each other.
#or if any of the x or y values are to close to the edge which is
# if x == 0 or x == 1600 or y = 0 or y == 920
#So a gigantic multiple if statement. which becomes smaller and smaller
#
#time.sleep(0.1)
print ("My program took", time.time() - start_time, "to run")
def main():
default_model_dir = 'all_models'
default_model = 'mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite'
default_labels = 'coco_labels.txt'
parser = argparse.ArgumentParser()
parser.add_argument('--model',
help='.tflite model path',
default=os.path.join(default_model_dir, default_model))
parser.add_argument('--labels',
help='label file path',
default=os.path.join(default_model_dir,
default_labels))
parser.add_argument(
'--top_k',
type=int,
default=3,
help='number of categories with highest score to display')
parser.add_argument('--camera_idx',
type=int,
help='Index of which video source to use. ',
default=0)
parser.add_argument('--threshold',
type=float,
default=0.1,
help='classifier score threshold')
args = parser.parse_args()
multiTracker = cv2.MultiTracker_create()
#Initialize logging files
logging.basicConfig(filename='storage/results.log',
format='%(asctime)s-%(message)s',
level=logging.DEBUG)
print('Loading {} with {} labels.'.format(args.model, args.labels))
interpreter = common.make_interpreter(args.model)
interpreter.allocate_tensors()
labels = load_labels(args.labels)
vs = PiVideoStream(resolution=(2048, 1536), framerate=32).start()
#cap = cv2.VideoCapture(args.camera_idx)
cap = vs.stream
#cap.set(3, 1920)
#cap.set(4, 1440)
# 4:3 resolutions
# 640×480, 800×600, 960×720, 1024×768, 1280×960, 1400×1050,
# 1440×1080 , 1600×1200, 1856×1392, 1920×1440, 2048×1536
# 5 MP
#cap.set(3, 2048)
#cap.set(4, 1536)
bboxes = []
colors = []
visitation = []
trackers = []
started_tracking = None
last_tracked = None
visitation_id = None
save_one_with_boxes = False
recording = False
out = None
fps = FPS().start()
is_stopped = False
current_fps = 4.0
while vs is not None:
try:
frame = vs.read()
if frame is not None:
if fps._numFrames < 500:
fps.update()
else:
fps.stop()
current_fps = fps.fps()
logging.info("[INFO] elasped time: {:.2f}".format(
fps.elapsed()))
logging.info("[INFO] approx. FPS: {:.2f}".format(
fps.fps()))
fps = FPS().start()
success, boxes = multiTracker.update(frame)
if success:
last_tracked = time.time()
if len(boxes) > 0:
logging.info("success {}".format(success))
logging.info("boxes {}".format(boxes))
cv2_im = frame
#cv2_im_rgb = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB)
pil_im = Image.fromarray(cv2_im)
common.set_input(interpreter, pil_im)
interpreter.invoke()
objs = get_output(interpreter,
score_threshold=args.threshold,
top_k=args.top_k)
height, width, channels = cv2_im.shape
bird_detected = False
boxes_to_draw = []
for obj in objs:
x0, y0, x1, y1 = list(obj.bbox)
x0, y0, x1, y1 = int(x0 * width), int(y0 * height), int(
x1 * width), int(y1 * height)
percent = int(100 * obj.score)
object_label = labels.get(obj.id, obj.id)
label = '{}% {}'.format(percent, object_label)
hdd = psutil.disk_usage('/')
if object_label == 'bird' and percent > 40:
bird_detected = True
new_bird = True
for bbox in boxes:
if intersects(bbox, obj.bbox):
logging.info("intersected.. same bird")
new_bird = False
if new_bird and len(bboxes) == 0:
logging.info("found a new bird")
visitation_id = uuid.uuid4()
started_tracking = time.time()
recording = True
save_one_with_boxes = True
bboxes.append(obj.bbox)
colors.append((randint(64, 255), randint(64, 255),
randint(64, 255)))
tracker = cv2.TrackerCSRT_create()
trackers.append(tracker)
multiTracker.add(tracker, cv2_im, obj.bbox)
if hdd.percent < 95:
boxed_image_path = "storage/detected/boxed_{}_{}_{}.png".format(
time.strftime("%Y-%m-%d_%H-%M-%S"), percent,
visitation_id)
full_image_path = "storage/detected/full_{}_{}_{}.png".format(
time.strftime("%Y-%m-%d_%H-%M-%S"), percent,
visitation_id)
cv2.imwrite(boxed_image_path, cv2_im[y0:y1, x0:x1])
if percent > 95:
cv2.imwrite(full_image_path, cv2_im)
else:
logging.info("Not enough disk space")
percent = int(100 * obj.score)
object_label = labels.get(obj.id, obj.id)
label = '{}% {}'.format(percent, object_label)
# postpone drawing so we don't get lines in the photos
boxes_to_draw.append({
"p1": (x0, y0),
"p2": (x1, y1),
"label": label,
"label_p": (x0, y0 + 30)
})
for box in boxes_to_draw:
cv2_im = cv2.rectangle(cv2_im, box["p1"], box["p2"],
(0, 255, 0), 2)
cv2_im = cv2.putText(cv2_im, box["label"], box["label_p"],
cv2.FONT_HERSHEY_SIMPLEX, 1.0,
(255, 0, 0), 2)
if recording == True:
if out == None:
fourcc = cv2.VideoWriter_fourcc(*'X264')
out = cv2.VideoWriter(
"storage/video/{}.avi".format(visitation_id),
fourcc, 4.0, (2048, 1536))
out.write(cv2_im)
if bird_detected == True and save_one_with_boxes == True:
with_boxes_image_path = "storage/with_boxes/full_{}_{}.png".format(
time.strftime("%Y-%m-%d_%H-%M-%S"), visitation_id)
cv2.imwrite(with_boxes_image_path, cv2_im)
save_one_with_boxes = False
if bird_detected == False and len(trackers) > 0:
now = time.time()
if now - last_tracked > 60:
logging.info("visitation {} lasted {} seconds".format(
visitation_id, now - started_tracking))
logging.info("clearing trackers")
for tracker in trackers:
tracker.clear()
multiTracker = cv2.MultiTracker_create()
boxes = []
colors = []
trackers = []
bboxes = []
recording = False
out.release()
out = None
for i, newbox in enumerate(boxes):
x0, y0, x1, y1 = list(newbox)
x0, y0, x1, y1 = int(x0 * width), int(y0 * height), int(
x1 * width), int(y1 * height)
cv2_im = cv2.rectangle(cv2_im, (x0, y0), (x1, y1),
(0, 0, 255), 2)
cv2.namedWindow('Leroy', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Leroy', 800, 600)
cv2.imshow('Leroy', cv2_im)
except KeyboardInterrupt:
print('Interrupted')
try:
sys.exit(0)
except SystemExit:
os._exit(0)
except:
logging.exception('Something happened.')
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
out.release()
vs.stop()
def cameraOptim():
time.sleep(2)
serialHandler = SerialHandler.SerialHandler("/dev/ttyACM0")
serialHandler.startReadThread()
serialHandler.sendPidActivation(True)
def moveForward():
serialHandler.sendMove(SPEED, -1.8)
print("Forward")
def moveLeft():
serialHandler.sendMove(SPEED, -23.0)
print("Left")
def moveRight():
serialHandler.sendMove(SPEED, 23.0)
print("Right")
def moveBackward():
serialHandler.sendMove(-SPEED, -1.8)
print("Back")
def dontMove():
serialHandler.sendMove(0, -1.8)
print("Break")
def region_of_interest(img, vertices):
mask = np.zeros_like(img)
match_mask_color = (255)
cv2.fillPoly(mask, vertices, match_mask_color)
masked_image = cv2.bitwise_and(img, mask)
return masked_image
def draw_lanes(img, lines, color=[0, 255, 255], thickness=3):
# if this fails, go with some default line
try:
ys = []
for i in lines:
for ii in i:
ys += [ii[1], ii[3]]
min_y = min(ys)
max_y = 600
new_lines = []
line_dict = {}
for idx, i in enumerate(lines):
for xyxy in i:
x_coords = (xyxy[0], xyxy[2])
y_coords = (xyxy[1], xyxy[3])
A = vstack([x_coords, ones(len(x_coords))]).T
m, b = lstsq(A, y_coords)[0]
x1 = (min_y - b) / m
x2 = (max_y - b) / m
line_dict[idx] = [m, b, [int(x1), min_y, int(x2), max_y]]
new_lines.append([int(x1), min_y, int(x2), max_y])
final_lanes = {}
for idx in line_dict:
final_lanes_copy = final_lanes.copy()
m = line_dict[idx][0]
b = line_dict[idx][1]
line = line_dict[idx][2]
if len(final_lanes) == 0:
final_lanes[m] = [[m, b, line]]
else:
found_copy = False
for other_ms in final_lanes_copy:
if not found_copy:
if abs(other_ms * 1.2) > abs(m) > abs(
other_ms * 0.8):
if abs(final_lanes_copy[other_ms][0][1] *
1.2) > abs(b) > abs(
final_lanes_copy[other_ms][0][1] *
0.8):
final_lanes[other_ms].append([m, b, line])
found_copy = True
break
else:
final_lanes[m] = [[m, b, line]]
line_counter = {}
for lanes in final_lanes:
line_counter[lanes] = len(final_lanes[lanes])
top_lanes = sorted(line_counter.items(),
key=lambda item: item[1])[::-1][:2]
lane1_id = top_lanes[0][0]
lane2_id = top_lanes[1][0]
def average_lane(lane_data):
x1s = []
y1s = []
x2s = []
y2s = []
for data in lane_data:
x1s.append(data[2][0])
y1s.append(data[2][1])
x2s.append(data[2][2])
y2s.append(data[2][3])
return int(mean(x1s)), int(mean(y1s)), int(mean(x2s)), int(
mean(y2s))
l1_x1, l1_y1, l1_x2, l1_y2 = average_lane(final_lanes[lane1_id])
l2_x1, l2_y1, l2_x2, l2_y2 = average_lane(final_lanes[lane2_id])
return [l1_x1, l1_y1, l1_x2, l1_y2], [l2_x1, l2_y1, l2_x2,
l2_y2], lane1_id, lane2_id
except Exception as e:
print(str(e))
def process_img(image):
original_image = image
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
processed_img = cv2.Canny(gray_image, 200, 300)
processed_img = cv2.GaussianBlur(processed_img, (5, 5), 0)
vertices = np.array([
[10, 500],
[10, 400],
[300, 250],
[500, 250],
[800, 500],
[800, 500],
], np.int32)
cropped_image = region_of_interest(processed_img, [vertices])
lines = cv2.HoughLinesP(cropped_image,
rho=1,
theta=np.pi / 180,
threshold=180,
lines=np.array([]),
minLineLength=20,
maxLineGap=15)
m1 = 0
m2 = 0
try:
l1, l2, m1, m2 = draw_lanes(original_image, lines)
cv2.line(original_image, (l1[0], l1[1]), (l1[2], l1[3]),
[0, 255, 0], 30)
cv2.line(original_image, (l2[0], l2[1]), (l2[2], l2[3]),
[0, 255, 0], 30)
except Exception as e:
print(str(e))
pass
try:
for coords in lines:
coords = coords[0]
try:
cv2.line(processed_img, (coords[0], coords[1]),
(coords[2], coords[3]), [255, 0, 0], 3)
except Exception as e:
print(str(e))
except Exception as e:
pass
return processed_img, original_image, m1, m2
ap = argparse.ArgumentParser()
ap.add_argument("-n",
"--num-frames",
type=int,
default=100,
help="# of frames to loop over for FPS test")
ap.add_argument("-d",
"--display",
type=int,
default=1,
help="Whether or not frames should be displayed")
args = vars(ap.parse_args())
print("[INFO] sampling THREADED frames from `picamera` module...")
vs = PiVideoStream().start()
last_time = time.time()
while (True):
frame = vs.read()
frame = imutils.resize(frame, width=800)
last_time = time.time()
new_screen, original_image, m1, m2 = process_img(frame)
print('Frame took {} seconds'.format(time.time() - last_time))
cv2.imshow(
'frame',
original_image) #se mai poate adauga argumentul cv2.COLOR_BGR2RGB
if (waitline != ser.readline()):
if m1 < 0 and m2 < 0:
moveRight()
time.sleep(0.1)
#dontMove()
elif m1 > 0 and m2 > 0:
moveLeft()
time.sleep(0.1)
#dontMove()
else:
moveForward()
time.sleep(0.1)
#dontMove()
else:
dontMove()
print("OBSTACLE AHEAD")
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
vs.stop()
stream.close()
rawCapture.close()
camera.close()
# created a *threaded *video stream, allow the camera sensor to warmup,
# and start the FPS counter
print("[INFO] sampling THREADED frames from `picamera` module...")
vs = PiVideoStream().start()
time.sleep(2.0)
fps = FPS().start()
# loop over some frames...this time using the threaded stream
while fps._numFrames < args["num_frames"]:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
frame = imutils.resize(frame, width=400)
# check to see if the frame should be displayed to our screen
if args["display"] > 0:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# update the FPS counter
fps.update()
# stop the timer and display FPS information
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
class QRDetector(object):
def __init__(self, flip = False):
self.vs = PiVideoStream(resolution=(800, 608)).start()
self.flip = flip
time.sleep(2.0)
def __del__(self):
self.vs.stop()
def flip_if_needed(self, frame):
if self.flip:
return np.flip(frame, 0)
return frame
def get_frame(self):
frame = self.flip_if_needed(self.vs.read())
frame = self.process_image(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
def process_image(self, frame):
pass
def decode(self, frame):
pass
def draw(self, frame, decoded_objs):
pass
@app.route('/stream')
def stream():
return Response(gen(),
mimetype='multipart/x-mixed-replace; boundary=frame')
def gen():
while True:
frame = get_frame()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
def get_frame():
camera.capture(rawCapture, format="bgr", use_video_port=True)
frame = rawCapture.array
decoded_objs = decode(frame)
frame = display(frame, decoded_objs)
ret, jpeg = cv2.imencode('.jpg', frame)
rawCapture.truncate(0)
return jpeg.tobytes()
def decode(frame):
decoded_objs = pyzbar.decode(frame, scan_locations=True)
for obj in decoded_objs:
print(datetime.now().strftime('%H:%M:%S.%f'))
print('Type: ', obj.type)
print('Data: ', obj.data)
return decoded_objs
def display(frame, decoded_objs):
for decoded_obj in decoded_objs:
left, top, width, height = decoded_obj.rect
frame = cv2.rectangle(frame,
(left, top),
(left + width, height + top),
(0, 255, 0), 2)
if __name__ == '__main__':
app.run(host="0.0.0.0", debug=False, threaded=True)
return frame
class DroidVisionThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.running = True
self.fps_counter = FPS().start()
self.camera = PiVideoStream(resolution=(config.RAW_FRAME_WIDTH, config.RAW_FRAME_HEIGHT))
self.camera.start()
time.sleep(config.CAMERA_WARMUP_TIME) # wait for camera to initialise
self.frame = None
self.frame_chroma = None
self.centre = config.CENTRE
self.can_see_lines = False
self.last_yellow_mean = config.WIDTH * 0.8
self.last_blue_mean = config.WIDTH * 0.2
self.desired_steering = config.NEUTRAL_STEERING # 0 = left, 0.5 = center, 1 = right
self.desired_throttle = config.NEUTRAL_THROTTLE # 0 = stop, 0.5 = medium speed, 1 = fastest
def run(self):
debug("DroidVisionThread: Thread started")
self.vision_processing()
self.camera.stop()
cv2.destroyAllWindows()
debug("DroidVisionThread: Thread stopped")
def stop(self):
self.running = False
debug("DroidVisionThread: Stopping thread")
def vision_processing(self):
while self.running:
self.grab_frame()
# colour mask
blue_mask = cv2.inRange(self.frame_chroma, config.BLUE_CHROMA_LOW, config.BLUE_CHROMA_HIGH)
yellow_mask = cv2.inRange(self.frame_chroma, config.YELLOW_CHROMA_LOW, config.YELLOW_CHROMA_HIGH)
colour_mask = cv2.bitwise_or(blue_mask, yellow_mask)
colour_mask = cv2.erode(colour_mask, config.ERODE_KERNEL)
colour_mask = cv2.dilate(colour_mask, config.DILATE_KERNEL)
# lines
lines = cv2.HoughLinesP(colour_mask, config.HOUGH_LIN_RES, config.HOUGH_ROT_RES, config.HOUGH_VOTES, config.HOUGH_MIN_LEN, config.HOUGH_MAX_GAP)
blue_lines = np.array([])
yellow_lines = np.array([])
if lines != None:
for line in lines:
x1,y1,x2,y2 = line[0]
angle = np.rad2deg(np.arctan2(y2-y1, x2-x1))
if config.MIN_LINE_ANGLE < abs(angle) < config.MAX_LINE_ANGLE:
if config.IMSHOW:
cv2.line(self.frame, (x1,y1), (x2,y2), (0,0,255), 1)
if angle > 0:
yellow_lines = np.append(yellow_lines, [x1, x2])
elif angle < 0:
blue_lines = np.append(blue_lines, [x1, x2])
# find centre
blue_mean = self.last_blue_mean
yellow_mean = self.last_yellow_mean
if len(blue_lines):
blue_mean = int(np.mean(blue_lines))
if len(yellow_lines):
yellow_mean = int(np.mean(yellow_lines))
self.centre = (blue_mean + yellow_mean) / 2.0
self.last_blue_mean = blue_mean
self.last_yellow_mean = yellow_mean
self.can_see_lines = (len(blue_lines) or len(yellow_lines))
# set steering and throttle
self.desired_steering = (1.0 - (self.centre / config.WIDTH))
if len(blue_lines) or len(yellow_lines):
self.desired_throttle = 0.22
else:
self.desired_throttle = 0
if config.IMSHOW:
cv2.circle(self.frame, (int(self.centre), config.HEIGHT - 20), 10, (0,0,255), -1)
cv2.imshow("colour_mask without noise", colour_mask)
cv2.imshow("raw frame", self.frame)
cv2.waitKey(1)
def grab_frame(self):
self.fps_counter.update()
# grab latest frame and index the ROI
self.frame = self.camera.read()
self.frame = self.frame[config.ROI_YMIN:config.ROI_YMAX, config.ROI_XMIN:config.ROI_XMAX]
# convert to chromaticity colourspace
B = self.frame[:, :, 0].astype(np.uint16)
G = self.frame[:, :, 1].astype(np.uint16)
R = self.frame[:, :, 2].astype(np.uint16)
Y = 255.0 / (B + G + R)
b = (B * Y).astype(np.uint8)
g = (G * Y).astype(np.uint8)
r = (R * Y).astype(np.uint8)
self.frame_chroma = cv2.merge((b,g,r))
def get_fps(self):
self.fps_counter.stop()
return self.fps_counter.fps()
def get_error(self):
return (config.CENTRE - self.centre)
def get_steering_throttle(self):
return self.desired_steering, self.desired_throttle
io.output(7, 0)
io.setup(11, io.OUT)
io.setup(13, io.OUT)
laser_h = io.PWM(11, 50)
laser_h.start(7.5)
laser_v = io.PWM(13, 50)
laser_v.start(7.5)
wd = 400
hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
wCam = WebcamVideoStream(src=0).start()
pCam = PiVideoStream().start()
sleep(2.0)
while True:
pFrame = pCam.read()
wFrame = wCam.read()
pFrame = imutils.resize(pFrame, width=wd)
wFrame = imutils.resize(wFrame, width=wd)
pFound, _ = hog.detectMultiScale(pFrame,
winStride=(8, 8),
padding=(8, 8),
scale=1.05)
wFound, _ = hog.detectMultiScale(wFrame,
winStride=(8, 8),
padding=(8, 8),
scale=1.05)
pFound = np.array([[x, y, x + w, y + h] for (x, y, w, h) in pFound])
wFound = np.array([[x, y, x + w, y + h] for (x, y, w, h) in wFound])
pFine = non_max_suppression(pFound, probs=None, overlapThresh=1)
wFine = non_max_suppression(wFound, probs=None, overlapThresh=1)
#init pygame timer
clock = pygame.time.Clock()
#global calibration array variables
imcalib = 0
imgain = 0
#frame variables
counter=0
mode=0
frame=0
#Pi Camera interface from imutils
vs = PiVideoStream(resolution=(width*2, height*2),framerate=30).start()
vsimage=vs.read()
try:
import pygame.surfarray as surfarray
except ImportError:
raise ImportError, "pygame failed to initialize"
#pygame font init
pygame.font.init()
myfont = pygame.font.SysFont('Nimbus Sans', 15)
#GUI variables
uiMenuItem = 0
uiSelector = 0
uiTimer=0
uiVisible = 0
else: if(not IS_IR_FIRED): search_mode() if __name__ == '__main__': vs = PiVideoStream().start() GPIO.setmode(GPIO.BOARD) time.sleep(0.5) while True: try: src = vs.read() src = cv2.flip(src, 1) #src = src[52:170, 0:320] find_box(image) if cv2.waitKey(1)==27: break except KeyboardInterrupt: break vs.stop() cv2.destroyAllWindows()
class CameraFeed:
# frame dimension (calculated below in go)
_frame_width = 0
_frame_height = 0
# how many frames processed
_frame = 0
def __init__(self,
source=0,
crop_x1=0,
crop_y1=0,
crop_x2=500,
crop_y2=500,
max_width=640,
b_and_w=False,
hog_win_stride=6,
hog_padding=8,
hog_scale=1.05,
mog_enabled=False,
people_options=None,
lines=None,
font=cv2.FONT_HERSHEY_SIMPLEX,
endpoint=None,
pi=False,
show_window=True,
to_stdout=False,
save_first_frame=False,
quit_after_first_frame=False,
camera_resolution=(1280, 720),
threaded=False):
self.__dict__.update(locals())
def go_config(self, config_path=None):
# load config
config = configparser.ConfigParser()
config.read(config_path)
# remote host settings
self.endpoint = config.get('host', 'endpoint', fallback=None)
# backend settings
project_name = 'test'
self.backend = FeedDB(project_name)
# platform
self.pi = config.getboolean('platform', 'pi')
self.to_stdout = config.getboolean('platform', 'to_stdout')
self.show_window = config.getboolean('platform', 'show_window')
self.save_first_frame = config.getboolean('platform',
'save_first_frame')
self.quit_after_first_frame = config.getboolean(
'platform', 'quit_after_first_frame')
self.threaded = config.getboolean('platform', 'threaded')
# video source settings
self.crop_x1 = config.getint('video_source', 'frame_x1')
self.crop_y1 = config.getint('video_source', 'frame_y1')
self.crop_x2 = config.getint('video_source', 'frame_x2')
self.crop_y2 = config.getint('video_source', 'frame_y2')
self.max_width = config.getint('video_source', 'max_width')
self.b_and_w = config.getboolean('video_source', 'b_and_w')
# hog settings
self.hog_win_stride = config.getint('hog', 'win_stride')
self.hog_padding = config.getint('hog', 'padding')
self.hog_scale = config.getfloat('hog', 'scale')
# mog settings
self.mog_enabled = config.getboolean('mog', 'enabled')
if self.mog_enabled:
self.mogbg = cv2.createBackgroundSubtractorMOG2()
# setup lines
lines = []
total_lines = config.getint('triplines', 'total_lines')
for idx in range(total_lines):
key = 'line%d' % (idx + 1)
start = eval(config.get('triplines', '%s_start' % key))
end = eval(config.get('triplines', '%s_end' % key))
buffer = config.getint('triplines', '%s_buffer' % key, fallback=10)
direction_1 = config.get('triplines',
'%s_direction_1' % key,
fallback='Up')
direction_2 = config.get('triplines',
'%s_direction_2' % key,
fallback='Down')
line = Tripline(point_1=start,
point_2=end,
buffer_size=buffer,
direction_1=direction_1,
direction_2=direction_2)
lines.append(line)
self.lines = lines
self.source = config.get('video_source', 'source')
if self.source == 'webcam':
self.webcam = True
else:
self.webcam = False
self.people_options = dict(config.items('person'))
self.go()
def go(self):
# setup HUD
self.last_time = time.time()
# opencv 3.x bug??
cv2.ocl.setUseOpenCL(False)
# people tracking
self.finder = PeopleTracker(people_options=self.people_options)
# STARTS HERE
# connect to camera
if self.pi:
if self.threaded == False:
print('non threading picamera started')
from picamera.array import PiRGBArray
from picamera import PiCamera
self.camera = PiCamera()
self.camera.resolution = self.camera_resolution
self.camera.framerate = 20
self.rawCapture = PiRGBArray(self.camera,
size=self.camera_resolution)
# threaded video_stream
else:
print('threading picamera started')
from imutils.video.pivideostream import PiVideoStream
from imutils.video import FPS
self.vs = PiVideoStream(resolution=self.camera_resolution,
framerate=20).start()
time.sleep(1) # let camera warm up
elif self.webcam:
self.camera = cv2.VideoCapture(1) #TODO check which webcam
self.camera.set(3, self.camera_resolution[0])
self.camera.set(4, self.camera_resolution[1])
else:
self.camera = cv2.VideoCapture(self.source)
# connect to backend
self.backend.connect()
# setup detectors
self.hog = cv2.HOGDescriptor()
self.hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
# feed in video
if self.pi:
if self.threaded == False:
for frame in self.camera.capture_continuous(
self.rawCapture, format="bgr", use_video_port=True):
image = frame.array
self.process(image)
self.rawCapture.truncate(0)
if self.quit_after_first_frame or cv2.waitKey(
1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
else:
while True:
frame = self.vs.read()
self.process(frame)
if self.quit_after_first_frame or cv2.waitKey(
1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
self.vs.stop()
elif self.webcam:
while self.camera.isOpened():
rval, frame = self.camera.read()
self.process(frame)
if self.quit_after_first_frame or cv2.waitKey(1) & 0xFF == ord(
'q'):
break
self.camera.release()
cv2.destroyAllWindows()
else:
while self.camera.isOpened():
rval, frame = self.camera.read()
self.process(frame)
if self.quit_after_first_frame or cv2.waitKey(1) & 0xFF == ord(
'q'):
break
self.camera.release()
cv2.destroyAllWindows()
def process(self, frame):
if self.b_and_w:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = self.crop_and_resize(frame)
print_frame_size = self._frame_height == 0
self._frame_height = frame.shape[0]
self._frame_width = frame.shape[1]
if print_frame_size and not self.to_stdout:
print('resized video to %dx%d' %
(self._frame_width, self._frame_height))
frame = self.apply_mog(frame)
frame = self.handle_the_people(frame)
frame = self.render_hud(frame)
if self.show_window:
cv2.imshow('Camerafeed', frame)
if self.to_stdout:
sys.stdout.write(frame.tostring())
# string = "".join(map(chr, frame.tostring()))
# sys.stdout.write(string)
if self.save_first_frame and self._frame == 0:
cv2.imwrite('first_frame.png', frame)
# help us crop/resize frames as they come in
def crop_and_resize(self, frame):
frame = frame[self.crop_y1:self.crop_y2, self.crop_x1:self.crop_x2]
frame = imutils.resize(frame,
width=min(self.max_width, frame.shape[1]))
return frame
# apply background subtraction if needed
def apply_mog(self, frame):
if self.mog_enabled:
mask = self.mogbg.apply(frame)
frame = cv2.bitwise_and(frame, frame, mask=mask)
return frame
# all the data that overlays the video
def render_hud(self, frame):
this_time = time.time()
diff = this_time - self.last_time
fps = 1 / diff
message = 'FPS: %d' % fps
# print(message)
cv2.putText(frame, message, (10, self._frame_height - 20), self.font,
0.5, (255, 255, 255), 2)
self.last_time = time.time()
return frame
def handle_the_people(self, frame):
(rects, weight) = self.hog.detectMultiScale(
frame,
winStride=(self.hog_win_stride, self.hog_win_stride),
padding=(self.hog_padding, self.hog_padding),
scale=self.hog_scale)
people = self.finder.people(rects)
# draw triplines
for line in self.lines:
for person in people:
if line.handle_collision(person) == 1:
self.new_collision(person)
frame = line.draw(frame)
for person in people:
frame = person.draw(frame)
person.colliding = False
return frame
def new_collision(self, person):
post = {
'name': person.name,
'meta': json.dumps(person.meta),
'time': time.time()
}
if self.endpoint is not None:
request = grequests.post(self.endpoint, data=post)
grequests.map([request])
if not self.to_stdout:
print("NEW COLLISION %s HEADING %s" %
(person.name, str(person.meta)))
self.backend.insert(post)
startup()
vs = PiVideoStream(SIZE, FPS).start()
time.sleep(3.0)
print("Camera done")
pygame.init()
display = pygame.display.set_mode(SIZE, 0)
possible_keys = [pygame.K_UP, pygame.K_DOWN, pygame.K_RIGHT, pygame.K_LEFT]
SIZE=SIZE[::-1]
frame_no = 1
strt = time.time()
while True:
cont = True
original_frame = vs.read()
# frame = original_frame
frame = cv2.flip(cv2.rotate(original_frame, cv2.ROTATE_90_CLOCKWISE), 1)
if frame is None:
print("Camera Error")
break
pygame_frame=cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)
gray_frame = cv2.cvtColor(cv2.flip(original_frame, -1), cv2.COLOR_BGR2GRAY)
arrw_src = (SIZE[0]/2, SIZE[1]/2)
arrw_dst = (SIZE[0]/2, SIZE[1]/2)
went_in = False
pygame.event.get()
key_input = pygame.key.get_pressed()
arrw_dst = get_arrow(key_input)
cont = do_action(key_input)
if cont is None or cont is False:
net = cv2.dnn.readNet('caffemodel/MobileNetSSD/MobileNetSSD_deploy.caffemodel',
'caffemodel/MobileNetSSD/MobileNetSSD_deploy.prototxt')
net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
net.setPreferableBackend(cv2.dnn.DNN_BACKEND_INFERENCE_ENGINE)
try:
vs = PiVideoStream((camera_width, camera_height)).start()
time.sleep(2)
while True:
t1 = time.perf_counter()
color_image = vs.read()
height = color_image.shape[0]
width = color_image.shape[1]
blob = cv2.dnn.blobFromImage(color_image,
size=(300, 300),
ddepth=cv2.CV_8U,
swapRB=False,
crop=False)
net.setInput(blob, scalefactor=1.0 / 127.5, mean=[127.5, 127.5, 127.5])
out = net.forward()
out = out.flatten()
for box_index in range(100):
if out[box_index + 1] == 0.0:
break
help="jffj")
args = vars(ap.parse_args())
cam = PiVideoStream()
cam = cam.start()
time.sleep(.5)
font = cv2.cv.InitFont(cv2.cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 1, 1)
while (True):
i = 0
if i == 1: # When output from motion sensor is HIGH
print("Intruder Detected")
GPIO.output(4, 1) # Turn ON LED
time.sleep(.5)
GPIO.output(4, 0)
lcd_string("Intruder Detect", LCD_LINE_1)
lcd_string(" Room 1", LCD_LINE_2)
img = cam.read()
img = imutils.resize(img, width=450)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gray, 1.2, 5)
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (225, 0, 0), 2)
Id, conf = recognizer.predict(gray[y:y + h, x:x + w])
name = " "
if (conf < 100):
if (Id == 1):
name = ""
elif (Id == 2):
name = ""
elif (Id == 3):
name = ""
def main(args):
# created a *threaded *video stream, allow the camera sensor to warmup,
# and start the FPS counter
vs = PiVideoStream().start() if args["picamera"] else WebcamVideoStream().start()
print("[INFO] warming up camera...")
time.sleep(2.0)
if not os.path.isdir(args["buffer"]):
os.makedirs(args["buffer"])
if not os.path.isdir(args["output"]):
os.makedirs(args["output"])
# initialize the FourCC, video writer, dimensions of the frame, and
# zeros array
fourcc = cv2.VideoWriter_fourcc(*args["codec"])
(h, w) = (None, None)
length = args["length"]
temp = list()
counter = 0
timeframe = 0
cv2.namedWindow("Frame", cv2.WINDOW_NORMAL)
params = {
"output": args["output"],
"buffer": args["buffer"],
"type": args["type"],
"length": length,
"fps": args["fps"],
"counter": 0,
"temp": None,
"frame": None,
"writer": None,
"idx": 0,
"res_code": 0
}
buffer_prefix = os.path.join(args["buffer"], buffer_name)
# loop over some frames...this time using the threaded stream
while True:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
frame = imutils.resize(frame, width=400)
if params["writer"] is None:
# store the image dimensions, initialzie the video writer,
# and construct the zeros array
(h, w) = frame.shape[:2]
params["writer"] = cv2.VideoWriter(buffer_prefix + "_" +
str(timeframe) + "." + args["type"],
fourcc, args["fps"], (w, h), True)
temp.append(frame)
counter += 1
params["counter"] = counter
params["temp"] = temp
params["frame"] = frame
if counter >= args["fps"]:
for img in temp:
params["writer"].write(img)
temp = list()
counter = 0
timeframe = (timeframe + 1) % length
params["timeframe"] = timeframe
params["writer"].release()
params["writer"] = cv2.VideoWriter(buffer_prefix + "_" +
str(timeframe) + "." + args["type"],
fourcc, args["fps"], (w, h), True)
if not q.empty():
flag = q.get()
if flag == 0:
params["writer"].release()
break
click(params)
# check to see if the frame should be displayed to our screen
if args["display"]:
cv2.imshow("Frame", frame)
print("[INFO] cleaning up...")
cv2.destroyAllWindows()
vs.stop()
print("[INFO] done")
class EntryLog:
def __init__(self):
self.recognizer = cv2.face.LBPHFaceRecognizer_create()
self.recognizer.read('trainer/trainer.yml')
self.cascadePath = "haarcascade/haarcascade_frontalface_default.xml"
self.faceCascade = cv2.CascadeClassifier(self.cascadePath)
self.ops = sys.platform
self.font = cv2.FONT_HERSHEY_DUPLEX
self.d = database.Database().getAll()
self.updated = False
if self.ops == 'win32':
# from imutils.video import WebcamVideoStream
# self.cam = WebcamVideoStream(src=0).start()
self.cam = cv2.VideoCapture(0)
else:
from imutils.video.pivideostream import PiVideoStream
self.cam = PiVideoStream().start()
self.ls = {}
for doc in self.d:
self.ls[doc['id']] = doc['name']
self.name = 'unknown'
self.idarr = []
self.i = 0
self.q = False
self.counts = 0
# params for ShiTomasi corner detection
self.feature_params = dict(maxCorners=100,
qualityLevel=0.3,
minDistance=7,
blockSize=7)
# Parameters for lucas kanade optical flow
self.lk_params = dict(winSize=(15, 15),
maxLevel=5,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
# define movement threshodls
self.max_head_movement = 20
self.movement_threshold = 50
if self.ops == 'win32':
self.gesture_threshold = 150
else:
self.gesture_threshold = 75
self.x = 0
self.y = 0
# find the face in the image
self.face_found = False
self.frame_num = 0
def get_coords(self, p1):
try:
return int(p1[0][0][0]), int(p1[0][0][1])
except:
return int(p1[0][0]), int(p1[0][1])
def attn(self):
# if self.ops == 'win32':
# # from imutils.video import WebcamVideoStream
# # self.cam = WebcamVideoStream(src=0).start()
# self.cam = cv2.VideoCapture(0)
# else:
# from imutils.video.pivideostream import PiVideoStream
# self.cam = PiVideoStream().start()
# self.cam = WebcamVideoStream(src=0).start()
while True:
if self.q:
break
while True:
if self.ops == 'win32':
ret, im = self.cam.read()
else:
im = self.cam.read()
self.gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
faces = self.faceCascade.detectMultiScale(self.gray, 1.2, 5)
if self.updated:
if (datetime.datetime.now() - self.t).total_seconds() < 2:
cv2.putText(im, 'Welcome ' + self.name, (50, 50), self.font, 0.8, (0, 255, 0), 2)
for (x, y, w, h) in faces:
cv2.rectangle(im, (x, y), (x + w, y + h), (225, 0, 0), 2)
Id, conf = self.recognizer.predict(self.gray[y:y + h, x:x + w])
self.face_found = True
if cv2.waitKey(10) == ord('q'):
self.q = True
break
if (conf >= 50):
self.name = self.ls.get(Id)
self.id = Id
# print(self.name, Id, conf)
self.idarr.append(Id)
cv2.putText(im, str(self.name), (x, y + h), self.font, 1, (255, 255, 255))
cv2.namedWindow("Entry")
cv2.imshow("Entry", im)
if cv2.waitKey(10) == ord('q'):
self.q = True
break
if len(self.idarr) == 30:
self.counts = np.bincount(np.array(self.idarr))
break
if self.q:
break
if self.face_found:
face_center = x + w / 2, y + h / 3
self.p0 = np.array([[face_center]], np.float32)
# self.ls.get(np.argmax())
if self.confirm():
now = datetime.datetime.now()
day = str(now.year) + '-' + str(now.month) + '-' + str(now.day)
log = []
d = database.Database().getlogbydate(day)
# if not d:
# m = {'_id': day, 'logs': []}
# database.Database().pushEntryLog(m)
# log = []
if d:
log = d['logs']
# self.now = datetime.datetime.now()
self.updated = True
l = {'id': self.id, 'name': self.name, 'timestamp': now.strftime("%H:%M:%S.%f")}
log.append(l)
database.Database().updatelog(day, log, self.name)
self.t = datetime.datetime.now()
if self.ops == 'win32':
self.cam.release()
else:
self.cam.stop()
cv2.waitKey(1)
cv2.destroyAllWindows()
def confirm(self):
self.idarr = []
self.counts = 0
if self.gesture():
return True
else:
return False
def gesture(self):
gesture = False
x_movement = 0
y_movement = 0
while True:
if self.ops == 'win32':
ret, frame = self.cam.read()
else:
frame = self.cam.read()
old_gray = self.gray.copy()
self.gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, self.gray, self.p0, None, **self.lk_params)
cv2.circle(frame, self.get_coords(p1), 4, (0, 0, 255), -1)
cv2.circle(frame, self.get_coords(self.p0), 4, (255, 0, 0))
# get the xy coordinates for points p0 and p1
a, b = self.get_coords(self.p0), self.get_coords(p1)
x_movement += abs(a[0] - b[0])
y_movement += abs(a[1] - b[1])
if not gesture: cv2.putText(frame, 'detected:', (50, 50), self.font, 0.8, (0, 0, 0), 2)
if not gesture: cv2.putText(frame, self.name, (180, 50), self.font, 0.8, (255, 0, 0), 2)
# text = 'x_movement: ' + str(x_movement)
text = 'nod to confirm'
if not gesture: cv2.putText(frame, text, (50, 100), self.font, 0.8, (0, 255, 0), 2)
# text = 'y_movement: ' + str(y_movement)
text = 'shake to cancel'
if not gesture: cv2.putText(frame, text, (50, 150), self.font, 0.8, (0, 0, 255), 2)
if cv2.waitKey(10) == ord('q'):
self.q = True
break
if x_movement > self.gesture_threshold:
self.updated = False
return False
if y_movement > self.gesture_threshold:
return True
self.p0 = p1
cv2.imshow("Entry", frame)
cv2.waitKey(1)
lk_params = dict(winSize=(25, 25),
maxLevel=7,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10,
0.03))
blur_params = (4, 4)
dilation_params = (5, 5)
movment_threshold = 180
active = False
frame_holder = None
# start capturing
vs = PiVideoStream().start()
time.sleep(2.0)
run_request = True
frame_holder = vs.read()
print("About to start.")
def FrameReader():
global frame_holder
while True:
frame = vs.read()
frame = imutils.resize(frame, width=400)
cv2.flip(frame, 1, frame)
frame_holder = frame
time.sleep(.03)
def Spell(spell):
#clear all checks
def printMouseCoords(event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDBLCLK:
print "Mouse at ({},{})".format(x, y)
# repeated timer for logging each x seconds
rt = RepeatedTimer(logInterval, collect)
# prepare windows for opencv and mouse listener
cv2.namedWindow('original')
cv2.setMouseCallback('original', printMouseCoords)
# infinite loop
while 1:
# 1) read the next frame
frame = cap.read()
# 2) convert current frame to gray and improve contrast with CLAHE (Contrast Limited Adaptive Histogram Equalization)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
cl1 = clahe.apply(gray)
# 3) do edge detection on grayscaled frame
edges = cv2.Canny(gray, 50, 70)
edges = ~edges
# 4) blur detected edges
blur = cv2.bilateralFilter(cv2.blur(edges, (21, 21), 100), 9, 200, 200)
# 5) apply threshold to frame: depending on pixel value, an array of 1s and 0s is created
_, threshold = cv2.threshold(blur, 230, 255, cv2.THRESH_BINARY)
# If debug flag is invoked
if args["debug"]:
# Start benchmark
print( fullStamp() + " [INFO] Debug Mode: ON" )
fps = FPS().start()
# ************************************************************************
# =========================> MAKE IT ALL HAPPEN <=========================
# ************************************************************************
# Infinite loop
while True:
# Get image from stream
frame = stream.read()[36:252, 48:336]
output = frame
# Add a 4th dimension (Alpha) to the captured frame
(h, w) = frame.shape[:2]
frame = numpy.dstack( [frame, numpy.ones( ( h, w ), dtype="uint8" ) * 255] )
# Create an overlay layer
overlay = numpy.zeros( ( h, w, 4 ), "uint8" )
# Convert into grayscale because HoughCircle only accepts grayscale images
bgr2gray = cv2.cvtColor( frame, cv2.COLOR_BGR2GRAY )
# Start thread to process image and apply required filters to detect circles
t_procFrame = Thread( target=procFrame, args=( bgr2gray, Q_procFrame ) )
t_procFrame.start()
def calibraPerclos(self):
self.judite.scriptInicial()
# Habilitando a captura de video
cap = PiVideoStream().start()
time.sleep(2.0)
start_time = time.time()
contImgCalibracao, contFPS = 0, 0
# Matriz da Razao de Aspecto
self.matrizRA = np.zeros((5, self.framesCalibragem))
displayFPS = 1 # Atualiza o FPS mostrado a cada segundo(s) setado na variavel.
b = True
while b:
frame = cap.read()
frameRedimencionado = imutils.resize(frame, width=400)
rgbImage = cv2.cvtColor(frameRedimencionado, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(frameRedimencionado, cv2.COLOR_BGR2GRAY)
retangulos = self.detectorCv.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
for (x, y, w, h) in retangulos:
retangulo = dlib.rectangle(int(x), int(y), int(x + w),
int(y + h))
self.shape = self.predicao(gray, retangulo)
self.shape = face_utils.shape_to_np(self.shape)
# Aquisição de dados para calibrar
if (contImgCalibracao < self.framesCalibragem):
if (contImgCalibracao == 0):
print(
str(time.localtime().tm_hour) + ":" +
str(time.localtime().tm_min) + ":" +
str(time.localtime().tm_sec) +
" - Aquisição de dados para calibração")
if (contImgCalibracao == (self.framesCalibragem // 2) - 1):
self.judite.scriptRegulagemOlhosAbertos()
self.matrizRA[0][
contImgCalibracao] = self.analisePERCLOS.razaoDeAspecto(
self.shape)
self.matrizRA[1][
contImgCalibracao] = self.analisePERCLOS.desvioPadrao(
contImgCalibracao, self.matrizRA)
self.matrizRA[2][
contImgCalibracao] = self.analisePERCLOS.erroPadrao(
contImgCalibracao, self.matrizRA)
self.matrizRA = self.preencherDadosDeTeste(
contImgCalibracao, self.matrizRA)
# Calibragem e plotagem dos dados de calibragem no gr�fico
elif (contImgCalibracao == self.framesCalibragem):
self.judite.scriptFimCalibragem()
self.matrizRA = self.analisePERCLOS.calibragemAberturaOlhos(
self.matrizRA)
arquivoCalibracao = ArquivoCalibracao()
arquivoCalibracao.gerarArquivoCalibracao(
self.matrizRA[0], self.usuario)
b = False
contImgCalibracao += 1
contFPS = contFPS + 1
if (time.time() - start_time) > displayFPS:
fps = int(contFPS / (time.time() - start_time))
print("FPS: {}".format(fps))
contFPS = 0
start_time = time.time()
# show the frame
if (self.display):
cv2.imshow("Calibracao", rgbImage)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
cv2.destroyAllWindows()
cap.stop()
time.sleep(5)
def ai():
cap = PiVideoStream(resolution=(208, 208)) #rpi camera
cap.start()
time.sleep(2.0)
cap.camera.hflip = True
cap.camera.vflip = True
print("[INFO] video recording")
## out = cv2.VideoWriter('avcnet.avi',cv2.VideoWriter_fourcc(*'XVID'), 10, (208,208))
# load the trained convolutional neural network
print("[INFO] loading network...")
## model = load_model("./avcnet_v1.model")
model = load_model("/home/pi/drone_exe/avcnet_best_5.hdf5",
custom_objects={"tf": tf})
# default parameters
orient = 0
tim_old = 0.1
state = 'fly'
dist = 510
global velocity_y
velocity_y = 0
fly_1 = 0.9
k = 0.83 # k=(tau/T)/(1+tau/T) tau time constant LPF, T period
while True:
start = time.time()
frame = cap.read()
orig = frame.copy()
frame = cv2.resize(frame, (64, 64))
frame = frame.astype("float") / 255.0
frame = img_to_array(frame)
frame = np.expand_dims(frame, axis=0)
# classify the input image
(stop, left, right, fly) = model.predict(frame)[0]
# build the label
## my_dict = {'stop':stop, 'left':left, 'right':right,'fly':fly}
my_dict = {'stop': stop, 'left': left, 'right': right}
maxPair = max(my_dict.iteritems(), key=itemgetter(1))
fly_f = k * fly_1 + (1 - k) * fly
fly_1 = fly_f
if state == 'avoid':
## label=maxPair[0]
## proba=maxPair[1]
if fly_f * 100 >= 60:
dist = 510
state = 'fly'
print >> f, state
else:
label = 'forward'
proba = fly
if fly_f * 100 <= 50:
dist = 180
label = maxPair[0]
proba = maxPair[1]
print >> f, my_dict
state = 'avoid'
label_1 = "{} {:.1f}% {}".format(label, proba * 100, state)
# draw the label on the image
output = imutils.resize(orig, width=208)
cv2.putText(output, label_1, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 255, 0), 2)
# Write the frame into the file 'output.avi'
## out.write(output)
if vehicle.channels['8'] > 1700:
event.clear()
if vehicle.channels['8'] > 1400 and vehicle.channels['8'] < 1700:
if state == "fly":
event.clear()
if state == "avoid":
event.set()
if label == 'left':
velocity_y = -0.5
if label == 'right':
velocity_y = 0.5
if label == 'stop':
velocity_y = 0
if vehicle.channels['8'] < 1400:
event.clear()
msg_sensor(dist, orient)
# show the output frame
cv2.imshow("Frame", output)
key = cv2.waitKey(10) & 0xFF
# if the `Esc` key was pressed, break from the loop
if key == 27:
break
# do a bit of cleanup
f.close()
print('end')
cv2.destroyAllWindows()
cap.stop()
frame_interval = StatValue()
last_frame_time = clock()
while True:
while len(pending) > 0 and pending[0].ready():
''' '''
res, t0 = pending.popleft().get()
latency.update(clock() - t0)
draw_str(res, (20, 20), "Latency: %.1f ms" % (latency.value*1000))
draw_str(res, (100, 20), "Frame interval: %.1f ms" % (frame_interval.value*1000))
print('Interval: %.lf ms',(frame_interval.value*1000))
#cv2.imshow('threaded video', res)
frame = cv2.medianBlur(frame, 19)
if len(pending) < threadn:
#camera.capture(rawCap, format = "bgr")
#frame = rawCap.array
frame = cap.read()
t = clock()
frame_interval.update(t - last_frame_time)
last_frame_time = t
if threaded_mode:
task = pool.apply_async(process_frame, (copy.copy(frame), t))
#task = pool.apply_async(process_frame, (frame, t))
else:
task = DummyTask(process_frame(frame, t))
#rawCap.truncate(0)
pending.append(task)
ch = 0xFF & cv2.waitKey(1)
if ch == ord(' '):
threaded_mode = not threaded_mode
if ch == 27:
break
def start_detecting(self, serial_connection):
print("ImageProcessor_start_detecting")
vs = PiVideoStream(resolution=(640, 480)).start()
time.sleep(2.0)
fps = FPS().start()
while True:
if not self.detect_image:
break
image = vs.read()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
gray = cv2.blur(gray, (5, 5))
# detect edges in the image
_, edged = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# find contours in the image
_, contours, _ = cv2.findContours(edged.copy(), cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)[:9]
centers = []
last_dimensions = []
for contour in contours:
# approximate the contour
peri = cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, 0.02 * peri, True)
# if the approximated contour has four points its a rectangle
if len(approx) == 4:
(x, y, w, h) = cv2.boundingRect(approx)
if h == 0:
h = 0.01
aspect_ratio = w / float(h)
# check if the rectangle is a square
if 0.85 <= aspect_ratio <= 1.15:
moments = cv2.moments(approx)
m00 = moments['m00']
if m00 == 0:
m00 = 0.05
# get the center of the square
cx = int(moments['m10'] / m00)
cy = int(moments['m01'] / m00)
is_duplicate = self.is_a_duplicate(
last_dimensions, h, w)
if not is_duplicate:
if self.check_if_target_found(
centers, cx, cy, serial_connection):
break
last_dimensions.append((w, h))
centers.append(np.array((cx, cy)))
fps.update()
fps.stop()
print('approx. FPS: {:.2f}'.format(fps.fps()))
vs.stop()
cv2.destroyAllWindows()
self.detect_image = True
self.slower_already_sent = False
