def calibrate(self):
while not self.buffer_full:
time.sleep(0.5)
cv2.namedWindow("Calibration")
cv2.startWindowThread()
cv2.setMouseCallback("Calibration", self.mouse_press)
self.calibration_index = 0
self.board_center = [(0,0)]*BUFFER_SIZE
self.fish_center = [(0,0)]*BUFFER_SIZE
t_steps = []
for img in self.calibration_buffer:
self.calibration_image = img[1]
t_steps.append(img[0])
self.calibration_phase = 'board'
cv2.imshow('Calibration', img[1])
k = cv2.waitKey(0)
self.calibration_index += 1
cv2.destroyWindow('Calibration')
# Now that we have some data let's use it
x = np.mean([point.x for point in self.board_center])
y = np.mean([point.y for point in self.board_center])
self.center_point = Point(x,y)
self._calibrate(self.center_point, self.fish_center, t_steps)
self.calibrated = True
def __init__(self):
cv2.namedWindow("detected circles", 1)
cv2.startWindowThread()
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("/turtlebot_2/camera/rgb/image_raw",
Image, self.callback)
def videoCapture(self):
number = 0
cv2.namedWindow("Drone %s" %self.numVehicle, cv2.cv.CV_WINDOW_NORMAL)
cv2.cv.ResizeWindow("Drone %s" %self.numVehicle, 640, 480)
cv2.startWindowThread()
while True:
capAux = cv2.VideoCapture(number)
if not (capAux.isOpened()):
break;
else:
number= number+1
capAux.release()
print number
if number >= 1:
self.capture = cv2.VideoCapture(1)
else:
self.capture = cv2.VideoCapture(0)
w = int(self.capture.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))
h = int(self.capture.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))
# video recorder
fourcc = cv2.cv.CV_FOURCC(*'XVID')
self.out = cv2.VideoWriter(time.strftime("Videos/%d-%m-%Y_%H:%M:%S")+".avi", fourcc, 25, (w, h))
if not self.capture.isOpened():
print chr(27) + "[0;31m" + "FPV system not connected.", ; print chr(27) + "[0m"
t0 = time.time()
result= ["Label not found"]
while self.capture.isOpened() and not self.stopVideoCapture:
coordY= 50
ch = 0xFF & cv2.waitKey(1)
ret, frame = self.capture.read()
if ret == True:
for i in result:
cv2.putText(frame, i, (20, coordY), cv2. FONT_HERSHEY_DUPLEX, 1.5, (0, 0, 255), 2)
coordY = coordY + 50
self.out.write(frame)
cv2.imshow("Drone %s" %self.numVehicle,frame)
timer = round((time.time() - t0) % self.secondsPerPhoto, 2)
if timer >= 0 and timer <= 0.99:
photoFile = time.strftime("Images/%d-%m-%Y_%H:%M:%S")+".jpg"
cv2.imwrite(photoFile, frame)
print chr(27) + "[1;33m" + "Drone %s: " %self.numVehicle + photoFile, "saved", ; print chr(27) + "[0m"
result = self.labelDetection(photoFile, result)
else:
break
self.capture.release()
self.out.release()
cv2.destroyWindow("Drone %s" %self.numVehicle)
cv2.waitKey(1)
cv2.waitKey(1)
cv2.waitKey(1)
cv2.waitKey(1)
def run(self):
# Waits for the image service to become available.
# This service is set up in camera_srv.py.
rospy.wait_for_service('last_image_global')
# Create the image capture function and save image
last_image_service = rospy.ServiceProxy('last_image_global', ImageSrv)
self.last_image = self.ros_to_np_img(last_image_service().image_data)
points = []
corners = ["bottom left boundary corner", "bottom right boundary corner", "top right boundary corner",
"top left corner", "fork goal point", "knife goal point", "spoon goal point"]
# Callback function taken from lab4 code. Adds a clicked
# point to the points list.
def on_mouse_click(event, x, y, flag, param):
if (event == cv2.EVENT_LBUTTONUP):
point = (x, y)
points.append(point)
if len(points) < 7:
print "Click on the " + corners[len(points)] + "."
else:
print "Done calibrating image."
# Comment out next two lines if debugging (CV2 bug)
cv2.startWindowThread()
cv2.namedWindow("CV Image")
# Display the CV Image
cv2.imshow("CV Image", self.last_image)
print "Click on the " + corners[0] + " boundary corner."
cv2.setMouseCallback("CV Image", on_mouse_click, param=1)
# Have user choose the four boundary corners for
# Zumy movement
while len(points) < len(corners):
if rospy.is_shutdown():
raise KeyboardInterrupt
cv2.waitKey(10)
# Exit out of picture
cv2.destroyAllWindows()
cv2.waitKey(1)
# | u1 u2 u3 u4 |
# | v1 v2 v3 v4 |
self.boundary_corners = np.array(points[:4]).T
self.goal_px_locations = {
'start': [points[0][0], points[0][1]],
'fork': [points[4][0], points[4][1]],
'knife': [points[5][0], points[5][1]],
'spoon': [points[6][0], points[6][1]]
}
self.create_homography()
if self.debug:
self.check_homography()
path = self.getPath({'destination': 'fork'})
print path
# Done with setup. Wait for path planning requests.
rospy.spin()
def __init__(self):
cv2.namedWindow("Image window", 1)
self.bridge = CvBridge()
cv2.startWindowThread()
self.imgthreshMultiplier = 3
self.imginfo = [0, 0] # x y
self.imgCenter = [0, 0] # xy
self.imgThreshold = [0, 0]
self.imgp = 0.1
self.headOdom = [0, 0] # yaw , pitch
self.imgin = 0
self.init = 0
self.habituation = 0
self.speechCount = 0
self.undetectedcount = 0
self.searching = False
self.state = 'nothing'
self.memoryProxy = ALProxy("ALMemory", robotIP, 9559)
# publisher
self.image_pub = rospy.Publisher("nao_detection", Image, queue_size=10)
self.behaviorpub = rospy.Publisher('/nao_behavior/add', String, queue_size=5)
self.headpub = rospy.Publisher('/nao_behavior/head', Float32MultiArray, queue_size=1)
# subscribers
self.image_sub = rospy.Subscriber("/camera/image_raw", Image, self.imgCallback)
self.statesub = rospy.Subscriber("/joint_states", JointState, self.jointstateC)
self.image = numpy.zeros((160, 120, 3), numpy.uint8)
self.voiceDetection = rospy.Subscriber("/nao_behavior/speech_detection", Bool, self.speechCallback)
def __enter__(self):
print "entering PrintSink"
print " starting cv2 window thread"
cv2.startWindowThread()
print ' creating cv2 window "input"'
cv2.namedWindow("input")
return self
def get_cams(self, image):
cv2.namedWindow("Screw")
cv2.startWindowThread()
cv2.setMouseCallback("Screw", self._get_screw)
self.screw_location = Point(0,0)
while True:
img = copy.copy(image)
cv2.circle(img, self.screw_location.to_image(), 3, (0,0,255), 3)
cv2.imshow('Screw', img)
k = cv2.waitKey(33)
if k==10:
# enter pressed
break
elif k==-1:
pass
else:
print k
print 'Press Enter to continue..'
cv2.destroyWindow('Screw')
arc = self.screw_location - self.board_center
cam_angle = arc.angle()
self.cam_angle = cam_angle
if len(self.base_cams) != 0:
self.cams = self.rotate(self.base_cams, cam_angle)
# self.cams = [c for c in self.cams if c.y <= 0]
self.locate_cams(image)
def showImage(name, image):
cv2.namedWindow(name, cv2.WINDOW_AUTOSIZE)
cv2.startWindowThread()
cv2.imshow(name, image)
cv2.waitKey(0)
cv2.destroyWindow(name)
cv2.waitKey(1)
def onScreen(self, degrees=None, scaleFactor=1):
"""I need something to display these things for debugging. This uses
OpenCV to display in a no-frills, any-key-to-dismiss window."""
if degrees:
im = Image.fromarray(self.rotate(degrees))
msg = "{} degree rotation - any key/click to continue".format(degrees)
else:
im = Image.fromarray(self.array)
msg = "any key/click to continue"
caption = "image display - any key to close"
cv2.namedWindow(caption, 0)
shape = im.shape
width = int(shape[1] * scaleFactor)
height = int(shape[0] * scaleFactor)
cv2.resizeWindow(caption, width, height)
# cv2.setMouseCallback(caption, kill_window)
cv2.imshow(caption, im)
cv2.startWindowThread()
cv2.waitKey(0)
cv2.destroyWindow(caption)
def takePic(path):
lastTime = time.time()
video_capture = cv2.VideoCapture(0)
cv2.startWindowThread()
cv2.namedWindow('Photobooth')
faceCascade = cv2.CascadeClassifier(cascadePath)
i = 0 #img number
while(True):
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=10,
minSize=(50,50),
flags=cv2.CASCADE_SCALE_IMAGE
)
for (x, y, w, h) in faces:
face = gray[y:y+h, x:x+w]
cv2.rectangle(frame, (x,y), (x+w, y+h), (0,0,255),2)
cv2.imshow('Photobooth', frame)
if time.time() - lastTime>5:
cv2.imwrite(path + '/' + str(i) + '.jpg', face)
lastTime = time.time()
i+=1
video_capture.release()
cv2.destroyAllWindows()
def resizeImage(file_path):
#Resize Cropping & Padding an image to the 640x480 pixel size
if file_path is not -1:
if check_image_with_pil(file_path):
image = Image.open(file_path)
image.thumbnail(size, Image.ANTIALIAS)
image_size = image.size
padding_0 = max( (size[0] - image_size[0]) / 2, 0 )
padding_1 = max( (size[1] - image_size[1]) / 2, 0 )
cv2.namedWindow('Original Image')
cv2.namedWindow('Resized Image')
cv2.startWindowThread()
orig_img = cv2.imread(file_path, 0)
cv2.imshow('Original Image',orig_img)
cv2.waitKey(2)
if((padding_0==0) & (padding_1==0)):
image.save(file_path, img_save_type)
else:
thumb = image.crop( (0, 0, size[0], size[1]) )
thumb = ImageChops.offset(thumb, int(padding_0), int(padding_1))
thumb.save(file_path)
resized_img = cv2.imread(file_path, 0)
cv2.imshow('Resized Image',resized_img)
else :
cv2.destroyAllWindows()
cv2.waitKey(2)
def onScreen(self, args=dict()):
"""I need something to display these things for debugging. This uses
OpenCV to display in a no-frills, any-key-to-dismiss window."""
if 'windowHeight' not in args:
args['windowHeight'] = 500
if 'delayAutoClose' not in args:
args['delayAutoClose'] = 10000
if 'scaleFactor' not in args:
height = float(self.data['spatialShape'][0])
args['scaleFactor'] = float(args['windowHeight'])/height
if 'message' not in args:
args['message'] = "image display - any key to close"
# def kill_window(event):
# cv2.destroyWindow(args['message'])
cv2.namedWindow(args['message'], 0)
shape = self.data['spatialShape']
width = int(shape[1] * args['scaleFactor'])
height = int(shape[0] * args['scaleFactor'])
cv2.resizeWindow(args['message'], width, height)
# cv2.setMouseCallback(args['message'], kill_window)
cv2.imshow(args['message'], self.array)
cv2.startWindowThread()
cv2.waitKey(args['delayAutoClose'])
cv2.destroyWindow(args['message'])
def encrypt_video_file_cat_map_stream(rounds, p, q):
numpy.set_printoptions(threshold='nan')
video = cv2.VideoCapture(0)
success, image = video.read()
width, height, depth = image.shape
# find the largest dimension
max_dimension = max(height, width)
cv2.startWindowThread()
cv2.namedWindow("enc1", cv.CV_WINDOW_AUTOSIZE)
cv2.namedWindow("dec1", cv.CV_WINDOW_AUTOSIZE)
while success:
# resize the image array to the largest dimension using black pixels
image.resize(max_dimension, max_dimension, depth)
# encrypt the image
arnold_chaotic_map(image, rounds, p, q)
# stream the encrypted image
cv2.imshow("enc1", image)
# decrypt the image
reverse_arnold_chaotic_map(image, rounds, p, q)
# resize to the original size
image.resize((width, height, depth))
# stream the decoded
cv2.imshow("dec1", image)
success, image = video.read()
return (width, height)
def loadpic(picaddress):
'''
loads a picture using opencv
pressing 'q' should close the windows, this doesnt work yet
input: path to the picture to load
'''
#read in the image
img = cv2.imread(picaddress)
#building windows
cv2.namedWindow('original', cv2.CV_WINDOW_AUTOSIZE)
cv2.namedWindow('process1', cv2.CV_WINDOW_AUTOSIZE)
#start a thread to keep track of events. Without this, we cannot close the window
cv2.startWindowThread()
#show the image
cv2.imshow('original', img)
#k = cv2.waitKey(0) # for 32 bit machine
k = cv2.waitKey(0) & 0xFF #for 64 bit machine
if k==ord('c'):
cv2.destroyAllWindows()
cv2.destroyWindow('original')
cv2.waitKey(1)
elif k == ord('q'):
cv2.destroyAllWindows()
cv2.destroyWindow('original')
cv2.waitKey(1)
def show(self):
if(self.img is None):
raise NoImageDefined()
cv2.namedWindow(self.windowname,0)
cv2.imshow(self.windowname, self.img)
cv2.startWindowThread()
def __init__(self, rom_file, frame_skip=1, viz=0):
"""
:param rom_file: path to the rom
:param frame_skip: skip every k frames
:param viz: the delay. visualize the game while running. 0 to disable
"""
self.ale = ALEInterface()
self.rng = get_rng(self)
self.ale.setInt("random_seed", self.rng.randint(self.rng.randint(0, 1000)))
self.ale.setInt("frame_skip", frame_skip)
self.ale.loadROM(rom_file)
self.width, self.height = self.ale.getScreenDims()
self.actions = self.ale.getMinimalActionSet()
if isinstance(viz, int):
viz = float(viz)
self.viz = viz
self.romname = os.path.basename(rom_file)
if self.viz and isinstance(self.viz, float):
cv2.startWindowThread()
cv2.namedWindow(self.romname)
self._reset()
self.last_image = self._grab_raw_image()
self.framenum = 0
def takeTracker():
cv2.startWindowThread()
cv2.namedWindow("InstaPy - InstaPhoto Tracker", 1)
cv2.setMouseCallback("InstaPy - InstaPhoto Tracker", getPixelRGB)
img.save('InstaPy Album/InstaPhotoTrack.png')
image = cv2.imread("InstaPy Album/InstaPhotoTrack.png")
cv2.imshow("InstaPy - InstaPhoto Tracker", image)
def CreateMashup():
global mashupPressed
blank_image = Image.new("RGB", (1290, 970))
_, frame = cap.read()
frame = cv2.flip(frame, 1)
cv2image = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
img = Image.fromarray(cv2image)
blank_image.paste(img, (0,0))
cv2image = cv2.cvtColor(frame, cv2.COLOR_RGB2HLS)
img = Image.fromarray(cv2image)
blank_image.paste(img, (650,0))
cv2image = cv2.cvtColor(frame, cv2.COLOR_RGB2YUV)
img = Image.fromarray(cv2image)
blank_image.paste(img, (0,490))
cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
img = Image.fromarray(cv2image)
blank_image.paste(img, (650,490))
blank_image.save("InstaPy Album/mashup.png")
mashupPressed = True
cv2.startWindowThread()
cv2.namedWindow("Mashup",1)
image = cv2.imread("InstaPy Album/mashup.png")
image = cv2.resize(image, (0,0), fx=0.70, fy=0.70)
cv2.imshow("Mashup", image)
def show_binary_image(image_bin, window_name, save = False, break_point = 0,\
max = 255):
"""Displays a binary image, optionally saves it to the current directory.
Parameters
----------
image_bin : numpy matrix of integers
The binary image that is asked to be displayed.
window_name : string
The name of the display window.
save : boolean
If the value is True then the binary image will be saved as a file.
break_point : int
Any pixel with a value greater than this value will be set to max
while the rest will be set to 0.
max_value : int
Any pixel with a value greater than break_point will be set to this
number while the rest will be set to 0.
Returns
-------
None
"""
image_show = get_binary_image(image_bin, break_point, 255)
cv2.startWindowThread()
cv2.namedWindow(window_name)
cv2.imshow(window_name, image_show)
cv2.waitKey(1)
if save:
cv2.imwrite(window_name + SUFFIX, image_show)
def __init__(self):
cv2.namedWindow("Live Image", 1)
cv2.namedWindow("Base Image", 1)
cv2.namedWindow("Original Image", 1)
cv2.startWindowThread()
self.bridge = CvBridge()
image_sub = Subscriber(
"/camera/rgb/image_color",
Image,
queue_size=1
)
person_sub = Subscriber(
"/upper_body_detector/detections",
UpperBodyDetector,
queue_size=1
)
depth_sub = Subscriber(
"/camera/depth/image_rect",
Image,
queue_size=1
)
# detections_image_sub = Subscriber(
# "/upper_body_detector/image",
# Image,
# queue_size=1
# )
ts = ApproximateTimeSynchronizer([image_sub, person_sub, depth_sub], 1, 0.1)
ts.registerCallback(self.image_callback)
def test_find_holes(self):
ft = FishTracker()
BAG_NAME = '../../fish_detective/bags/2016-04-06-16-57-50.bag' #1437
# BAG_NAME = '../../fish_detective/training/bags/three_fish.bag'
bag = rosbag.Bag(BAG_NAME)
imgs = self.get_ros_img(bag)
zero = imgs.next()
# import IPython; IPython.embed()
ft.find_holes(zero)
fishes = ft.track_holes(zero)
cv2.namedWindow("Calibration")
cv2.startWindowThread()
cv2.imshow('Calibration', fishes)
k = cv2.waitKey(0)
one = imgs.next()
ft.find_holes(one)
fishes = ft.track_holes(one)
cv2.imshow('Calibration', fishes)
k = cv2.waitKey(0)
for i in range(60):
im = imgs.next()
ft.find_holes(im)
fishes = ft.track_holes(im)
cv2.imshow('Calibration', fishes)
k = cv2.waitKey(1)
cv2.destroyWindow('Calibration')
def __init__(self):
cv2.namedWindow("Image window", 1)
cv2.startWindowThread()
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("/usb_cam/image_raw",
Image, self.callback)
def main():
rospy.init_node(node_name) # check to see if launch file remaps this
try:
cv2.namedWindow(win1_name, flags=cv2.cv.WINDOW_NORMAL) #see if flag is necessary
# cv2.NamedWindow(win2_name, flags=WINDOW_NORMAL)
cv2.moveWindow(win1_name,200,0)
# cv2.MoveWindow(win2_name,200,300)
cv2.resizeWindow(win1_name,100,300)
# cv2.ResizeWindow(win2_name,100,300)
cv2.startWindowThread()
rospy.on_shutdown(cleanup)
# rate = rospy.Rate(freq)
sub_RBG = rospy.Subscriber("/camera/rgb/image_color", Image, callback_rbg)
# sub_depth = rospy.Subscriber("/camera/depth/image_raw", Image, callback_depth)
print('==========Initializing Subscribers=====')
rospy.sleep(1)
# while not rospy.is_shutdown():
# rospy.rate=1
# rospy.wait_for_message("/camera/rgb/image_color", Image, timeout=None)
# k = cv2.waitKey(0) & 0xFF
# if k==27:
# cleanup()
# # rate.sleep()
rospy.spin()
except KeyboardInterrupt:
print "Shutting down"
cleanup()
def getIndividualColour(h,s,v, colourname):
cv2.startWindowThread()
# Create a black image, a window
img = np.zeros((300,512,3), np.uint8)
cv2.namedWindow('image')
# create trackbars for color change
cv2.createTrackbar('H','image',h,179,nothing)
cv2.createTrackbar('S','image',s,255,nothing)
cv2.createTrackbar('V','image',v,255,nothing)
# create tracker for which colour value we want to set
# i.e. 1= blue, 2 = red, etc.
while(1):
img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
cv2.imshow('image',img)
k = cv2.waitKey(10) & 0xFF
if k == 27:
break
if k == 97:
print("Returning values of [" + str(r) + ", " + str(g) + ", " + str(b) + "] for colour \"" + colourname + "\".")
# get current positions of four trackbars
r = cv2.getTrackbarPos('H','image')
g = cv2.getTrackbarPos('S','image')
b = cv2.getTrackbarPos('V','image')
img[:] = [r,g,b]
cv2.destroyWindow('image')
cv2.waitKey(1)
return [r,g,b]
def __init__(self):
namedWindow("Image window", 1)
namedWindow("blur", 1)
self.bridge = CvBridge()
startWindowThread()
self.image_sub = rospy.Subscriber("/turtlebot_1/camera/rgb/image_raw",
Image, self.callback)
def displayImage(self, windowName="Look at lines of interest"):
image = self.imageWithLines()
# Display the image and disappear when a key is hit
cv2.namedWindow(windowName, cv2.WINDOW_AUTOSIZE)
cv2.startWindowThread()
cv2.imshow(windowName, image)
cv2.waitKey(0)
cv2.destroyAllWindows()
def recivedEvent(self, notifyId):
if notifyId == ID_NOTIFY_LOADED_VIDEO:
im = self.__presenter.getPreviewImage()
print(im)
if im is not None:
cv2.startWindowThread()
cv2.namedWindow("preview")
cv2.imshow("preview", im)
def main():
rospy.init_node("depth_view")
rospy.Subscriber("image", Image, new_image)
cv2.namedWindow(WINDOW_NAME)
cv2.startWindowThread()
rospy.spin()
def __init__(self, rom_file, viz=0, height_range=(None,None),
frame_skip=4, image_shape=(84, 84), nullop_start=30,
live_lost_as_eoe=True):
"""
:param rom_file: path to the rom
:param frame_skip: skip every k frames and repeat the action
:param image_shape: (w, h)
:param height_range: (h1, h2) to cut
:param viz: visualization to be done.
Set to 0 to disable.
Set to a positive number to be the delay between frames to show.
Set to a string to be a directory to store frames.
:param nullop_start: start with random number of null ops
:param live_losts_as_eoe: consider lost of lives as end of episode. useful for training.
"""
super(AtariPlayer, self).__init__()
self.ale = ALEInterface()
self.rng = get_rng(self)
self.ale.setInt("random_seed", self.rng.randint(0, 10000))
self.ale.setBool("showinfo", False)
try:
ALEInterface.setLoggerMode(ALEInterface.Logger.Warning)
except AttributeError:
log_once()
self.ale.setInt("frame_skip", 1)
self.ale.setBool('color_averaging', False)
# manual.pdf suggests otherwise. may need to check
self.ale.setFloat('repeat_action_probability', 0.0)
# viz setup
if isinstance(viz, six.string_types):
assert os.path.isdir(viz), viz
self.ale.setString('record_screen_dir', viz)
viz = 0
if isinstance(viz, int):
viz = float(viz)
self.viz = viz
if self.viz and isinstance(self.viz, float):
self.windowname = os.path.basename(rom_file)
cv2.startWindowThread()
cv2.namedWindow(self.windowname)
self.ale.loadROM(rom_file)
self.width, self.height = self.ale.getScreenDims()
self.actions = self.ale.getMinimalActionSet()
self.live_lost_as_eoe = live_lost_as_eoe
self.frame_skip = frame_skip
self.nullop_start = nullop_start
self.height_range = height_range
self.image_shape = image_shape
self.current_episode_score = StatCounter()
self.restart_episode()
def set_user_params(self):
'''Is responsible for displaying each image of the data point folder.
Works with self.paramsUI to gather input from the user'''
self.stage = 0
global TESTING
for i in range(len(self.imgs)):
if TESTING and i != 0:
self.user_params[i]['testing_region'] = self.user_params[0]['testing_region']
else:
self.i = i
self.drawing_overlay = self.imgs[i].__copy__()
if sys.platform.startswith('win'):
import ctypes
user32 = ctypes.windll.user32
screen_res = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
else:
status, output = commands.getstatusoutput("xrandr | grep '*'")
if not status:
screen_res = tuple(
[int(dim) for dim in \
[
part for part in output.split('\n')[-1].split(' ') if part][0].split('x')
]
)
else:
screen_res = 800, 600
scale_width = screen_res[0] / float(self.imgs[i].shape[1])
scale_height = screen_res[1] / float(self.imgs[i].shape[0])
scale = min(scale_width, scale_height)
window_width = int(self.imgs[i].shape[1] * scale)
window_height = int(self.imgs[i].shape[0] * scale)
cv2.namedWindow(self.img_names[i], cv2.WINDOW_NORMAL)
cv2.startWindowThread()
cv2.resizeWindow(self.img_names[i], window_width, window_height)
self.ix, self.iy = -1, -1
if i == 0:
cv2.putText(self.drawing_overlay, 'Select testing region', (20, 100), \
cv2.FONT_HERSHEY_COMPLEX, 2, (255, 255, 0), 5)
else:
cv2.putText(self.drawing_overlay, 'Place testing region', (20, 100), \
cv2.FONT_HERSHEY_COMPLEX, 2, (255, 255, 0), 5)
cv2.setMouseCallback(self.img_names[i], self.paramsUI)
cv2.imshow(self.img_names[i], self.drawing_overlay)
while True:
k = cv2.waitKey(5)
if k == 27:
print 'User Interrupt: exiting'
exit()
elif k == ord('n'):
self.stage = 0
cv2.destroyWindow(self.img_names[i])
cv2.waitKey(1)
break
def _main_():
config_path = 'config_cargo_door.json'
weights_path = '/media/ubuntu/hdd/tensorflow_data/YOLO/CargoDoor/full_yolo_cargo_door.h5'
image_path = '/media/ubuntu/DANFOSS/airport_images.tar.gz/015.jpg'
with open(config_path) as config_buffer:
config = json.load(config_buffer)
###############################
# Make the model
###############################
yolo = YOLO(architecture=config['model']['architecture'],
input_size=config['model']['input_size'],
labels=config['model']['labels'],
max_box_per_image=config['model']['max_box_per_image'],
anchors=config['model']['anchors'])
###############################
# Load trained weights
###############################
print(weights_path)
yolo.load_weights(weights_path)
###############################
# Predict bounding boxes
###############################
cv2.namedWindow("Detection", cv2.WINDOW_NORMAL)
cv2.startWindowThread() #to make sure we can close it later on
if image_path[-4:] == '.mp4':
video_reader = cv2.VideoCapture(image_path)
nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT))
frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT))
frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH))
for i in range(nb_frames):
_, image = video_reader.read()
boxes = yolo.predict(image)
image = draw_boxes(image, boxes, config['model']['labels'])
print len(boxes), 'box(es) found'
#display frame
image_np = np.uint8(image)
cv2.imshow("Detection", image_np)
k = cv2.waitKey(0) & 0xEFFFFF
if k == 27:
print("You Pressed Escape")
break
video_reader.release()
else:
image = cv2.imread(image_path)
#Predict and time it
t0 = time.time()
boxes = yolo.predict(image)
t1 = time.time()
total = t1 - t0
#overlay boxes
image = draw_boxes(image, boxes, config['model']['labels'])
#feedback
print len(boxes), 'box(es) found'
print 'Prediciton took %f seconds' % (total)
#display frame
cv2.imshow("Detection", image)
k = cv2.waitKey(0) & 0xEFFFFF
if k == 27:
print("You Pressed Escape")
cv2.destroyAllWindows()
for i in range(1, 5):
cv2.waitKey(1)
def detect_and_track_multiple_faces():
# open cam device
cam = cv2.VideoCapture(1)
# create 2 opencv named windows
cv2.namedWindow('base-image', cv2.WINDOW_AUTOSIZE)
cv2.namedWindow('result-image', cv2.WINDOW_AUTOSIZE)
# position the windows next to eachother
cv2.moveWindow('base-image', 0, 100) #x, y
cv2.moveWindow('result-image', 400, 100)
# start window thread for 2 windows
cv2.startWindowThread()
# color of rect we draw around face
rect_color = (0, 165, 255)
# var holding cur frame, cur faceId
frame_counter = 0
cur_face_id = 0
# var holding correlation trackers, and name per faceId
face_trackers = {} # fid => tracker
face_names = {}
try:
while True:
# retrieve latest img from webcam
time_start = time.time()
ok, full_size_base_img = cam.read()
# resize img to 320x240
base_img = cv2.resize(full_size_base_img, (320, 240))
# check if a key press, if it was q, destroy all
# windows
k = cv2.waitKey(2)
if k == ord('q'):
break
# result img, the one we show user
# result = original + rects
result_img = base_img.copy()
# STEPS:
# * Update all trackers and remove the ones
# that are not relevant anymore
# * Every 10 frames:
# + Use face detection on cur frame
# and look for faces
# + For each found face, check if centerpoint
# is within existing tracked box. If so,
# do nothing
# + If centerpoint is NOT in existing tracked box,
# then we add a new tracker with a new face-id
# increase frame counter
frame_counter += 1
# update all trackers and remove the ones for which
# the update indicated the quality was not good enough
fids_to_delete = []
for fid in face_trackers.keys():
tracking_quality = face_trackers[fid].update(base_img)
# if track quality is NOT good enough, we
# must del this tracker
if tracking_quality < 7:
fids_to_delete.append(fid)
for fid in fids_to_delete:
print("Remove fid: " + str(fid) + " from list of trackers")
face_trackers.pop(fid, None)
# Every 10 frames, determine which faces
# are present in frame
if (frame_counter % 10) == 0:
# for face detection, use gray color image
gray = cv2.cvtColor(base_img, cv2.COLOR_BGR2GRAY)
# now, use haar cascade to find all faces
# in image
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
# loop over all faces
for (_x, _y, _w, _h) in faces:
x = int(_x)
y = int(_y)
w = int(_w)
h = int(_h)
# cal centerpoint
x_bar = x + 0.5*w
y_bar = y + 0.5*h
# var holding infor which faceId we matched with
match_fid = None
# now loop over all trackers and check if
# center point of the face is within
# box of a tracker
for fid in face_trackers.keys():
track_position = face_trackers[fid].get_position()
t_x = int(track_position.left())
t_y = int(track_position.top())
t_w = int(track_position.width())
t_h = int(track_position.height())
# cal centerpoint
t_x_bar = t_x + 0.5*t_w
t_y_bar = t_y + 0.5*t_h
# check if center point of face is within
# the rect of a tracker region.
# Also, the centerpoint of tracker region must
# be within the region detected as a face
# if both of these conditions hold
# we have a match
if (
# center of face
(t_x <= x_bar <= (t_x + t_w)) and
(t_y <= y_bar <= (t_y + t_h)) and
# center of track
(x <= t_x_bar <= (x + w)) and
(y <= t_y_bar <= (y + h))
):
match_fid = fid
# if no matched fid, then have to create a new tracker
if match_fid is None:
print("create a new tracker " + str(cur_face_id))
# create and store the tracker
tracker = dlib.correlation_tracker()
tracker.start_track(base_img,
dlib.rectangle(
x - 10,
y - 20,
x + w + 10,
y + h + 20
))
face_trackers[cur_face_id] = tracker
# start a new thread, to simulate face recognition
# not yet implemented in this version
# t = threading.Thread(
# target= recognize_person,
# args = (face_names, cur_face_id)
# )
# t.start()
# increase curfaceId counter
cur_face_id += 1
# end 10 frame-if
# now loop over all trackers and raw rect
# around detected faces.
for fid in face_trackers.keys():
track_position = face_trackers[fid].get_position()
t_x = int(track_position.left())
t_y = int(track_position.top())
t_w = int(track_position.width())
t_h = int(track_position.height())
cv2.rectangle(result_img,
(t_x, t_y),
(t_x + t_w, t_y + t_h),
rect_color, 2)
# write name ...
# not implemented yet
# show large result
large_result = cv2.resize(result_img,
(OUTPUT_SIZE_WIDTH, OUTPUT_SIZE_HEIGHT))
# finally, show images on screen
time_end = time.time()
fps = int(1/(time_end-time_start))
fps_display = "fps: " + str(fps)
cv2.putText(large_result, fps_display, (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.imshow('base-image', base_img)
cv2.imshow('result-image', large_result)
# if user press Ctrol-C in console
# break out of main loop
except KeyboardInterrupt as e:
pass
# destroy openCV windows
cv2.destroyAllWindows()
exit(0)
def refine(facial_feature, thresh=0, os=mac):
"""
Args:
dir: (string) directory of one group of data
mode: (string) decide whether to move or click to change the joint point
"""
mode = 'drag'
anno = AnnotationLoader(facial_feature, threshold=thresh)
# app = MyCollectApp()
anno.window_name = 'refining'
cv2.namedWindow(anno.window_name)
idx = 0
while idx < len(anno.data_files):
anno.cur_file = anno.data_files[idx]
# if anno.data_files[idx]
# anno.window_name = dir.split('/')[-1] + '/' + anno.cur_file
anno.img = anno.lood_img(idx)
# anno.img -= anno.img # To show black canvas
img = anno.img.copy()
# img = np.zeros((360, 640, 3))
# cv2.namedWindow(anno.window_name)
anno.plot_skeleton(img, anno.cur_file, thick=2)
if mode == 'drag':
cv2.setMouseCallback(anno.window_name, anno.MouseCallback_drag)
elif mode == 'click':
cv2.setMouseCallback(anno.window_name, anno.MouseCallback_click)
else:
print("No mode named:" + mode)
cv2.startWindowThread()
cv2.imshow(anno.window_name, img)
while True:
# By judging status, the program could be more responsive.
if anno.deleting:
if cv2.waitKey(10) == os: # Backspace
del anno.annotation[anno.cur_file][anno.person_selected]
anno.deleting = False
anno.person_selected = -1
anno.joint_selected = ''
img = anno.img.copy(
) # clear all skeleton drawn on the image
anno.plot_skeleton(img, anno.cur_file, thick=2)
cv2.imshow(anno.window_name, img)
else:
key = cv2.waitKey(10)
if key == 13 or key == 3 or key == 100: # Enter or D button
anno.joint_selected = False
anno.revise(anno.cur_file)
idx += 1
break
elif key == 2 or key == 97:
if idx >= 1:
idx -= 1
break
elif key == 32: # Space
global add_joint_num
anno.adding = True
anno.add_joint_num = int(
input("Please input the joint number:")) + 1
# pop_box()
# anno.add_joint_num = int(anno.add_joint_num) + 1
# add_joint_num = ''
# anno.revise()
cv2.destroyAllWindows()
cv2.waitKey(1)
cv2.waitKey(1)
cv2.waitKey(1)
cv2.waitKey(1)
for contour in contours:
area = cv2.contourArea(contour)
if area > max_area:
max_area = area
best_contour = contour
M = cv2.moments(best_contour)
cx, cy = int(M['m10']/M['m00']), int(M['m01']/M['m00'])
cv2.circle(blur, (cx, cy), 10, (0, 0, 255), -1)
###########
#cv2.imshow("Frame", blur) #displays the image
cv2.imshow("Frame - Threshold", thresh2)
#cv2.imshow("frame", image) #shows contours
cv2.startWindowThread() #has to be used in order to actually close the window
key = cv2.waitKey(1) & 0xFF #has to be used in conjunction with imshow, to close window
rawCapture.seek(0) #goes to the first image in the array
rawCapture.truncate(0) #deletes previously seen image
#closes the program when you hit q
if key == ord("q"):
cv2.destroyAllWindows()
break
#actual image stuff
self.car_pos_dir,
'car_pos' + str('{:06d}'.format(self.img_count)) + '.yaml')
cv2.imwrite(cameraFront_img_name, self.cameraFront_img)
cv2.imwrite(cameraRight_img_name, self.cameraRight_img)
cv2.imwrite(cameraBack_img_name, self.cameraBack_img)
cv2.imwrite(cameraLeft_img_name, self.cameraLeft_img)
cv2.imwrite(cameraAll_img_name, self.cameraAll)
car_pose_stream = open(car_pose_name, "w")
car_data = {
'car_pos': self.car_pos.tolist(),
'car_ori': self.car_ori.tolist()
}
yaml.dump(car_data, car_pose_stream)
self.lock.release()
self.img_count += 1
if self.img_count > 100000:
sys.exit()
if __name__ == "__main__":
rospy.init_node('save_pics_sync')
cv2.startWindowThread()
ss = saver()
rate = rospy.Rate(50)
while not rospy.is_shutdown():
ss.save_pics()
def detect(url_or_np_array):
# check if i get a url (= string) or np.ndarray
if isinstance(url_or_np_array, basestring):
try:
response = requests.get(url_or_np_array, timeout=10) # download
full_image = cv2.imdecode(np.asarray(bytearray(response.content)),
1)
except:
print "couldn't open link"
return None
elif type(url_or_np_array) == np.ndarray:
full_image = url_or_np_array
else:
return None
if full_image is None:
print "not a good image"
return None
# faces = find_face_dlib(full_image, 1)
#
# if not faces["are_faces"]:
# print "didn't find any faces"
# return None
image = imutils.resize(full_image, width=500)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale image
rects = detector(gray, 1)
faces_list = [[rect.left(),
rect.top(),
rect.width(),
rect.height()] for rect in list(rects)]
if not len(faces_list):
print "didn't find a face!"
return
print "rects: {}".format(faces_list)
# loop over the face detections
for (i, rect) in enumerate(rects):
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
# convert dlib's rectangle to a OpenCV-style bounding box
# [i.e., (x, y, w, h)], then draw the face bounding box
(x, y, w, h) = face_utils.rect_to_bb(rect)
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
# show the face number
cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# loop over the (x, y)-coordinates for the facial landmarks
# and draw them on the image
for j, (x, y) in enumerate(shape):
if j + 1 in eyes_landmarks:
cv2.circle(image, (x, y), 1, (255, 0, 0), -1)
eyes_dict[j + 1] = (x, y)
else:
cv2.circle(image, (x, y), 1, (0, 0, 255), -1)
# cv2.line(image, eyes_dict[38], eyes_dict[41], (255, 0, 0), 2)
# cv2.line(image, eyes_dict[39], eyes_dict[42], (255, 0, 0), 2)
# cv2.line(image, eyes_dict[44], eyes_dict[47], (255, 0, 0), 2)
# cv2.line(image, eyes_dict[45], eyes_dict[48], (255, 0, 0), 2)
left_eye_x, left_eye_y = int(
np.mean([
eyes_dict[38][0], eyes_dict[39][0], eyes_dict[41][0],
eyes_dict[42][0]
])), int(
np.mean([
eyes_dict[38][1], eyes_dict[39][1], eyes_dict[41][1],
eyes_dict[42][1]
]))
right_eye_x, right_eye_y = int(
np.mean([
eyes_dict[44][0], eyes_dict[45][0], eyes_dict[47][0],
eyes_dict[48][0]
])), int(
np.mean([
eyes_dict[44][1], eyes_dict[45][1], eyes_dict[47][1],
eyes_dict[48][1]
]))
cv2.circle(image, (left_eye_x, left_eye_y), 1, (0, 255, 0), -1)
cv2.circle(image, (right_eye_x, right_eye_y), 1, (0, 255, 0), -1)
left_eye = np.array((left_eye_x, left_eye_y))
right_eye = np.array((right_eye_x, right_eye_y))
print "distance between eyes: {}".format(
np.linalg.norm((right_eye) - (left_eye)))
# print "distance between eyes: {}".format(np.sqrt(np.sum(((right_eye_x, right_eye_y) - (left_eye_x, left_eye_y))**2)))
# print cv2.imwrite("/data/yonatan/linked_to_web/face_landmarks/image3.jpg", image)
cv2.namedWindow("Output", cv2.CV_WINDOW_AUTOSIZE)
cv2.startWindowThread()
cv2.imshow("Output", image)
cv2.waitKey(0)
def click_estimate_diameter():
newWindow = Toplevel(root)
newWindow.geometry('600x600+800+100')
newWindow.iconbitmap("e:\cnts_sem\icon3.ico")
newWindow.attributes("-topmost", True)
ifile = filedialog.askopenfilename(initialdir="/", title="Select a file",
filetypes=(("png files", "*.png"), ("all files", "*.*")))
path = ifile
im = cv2.imread(path)
#print(len(im), len(im[0]))
boxes1 = []
def on_mouse_0(event, x, y, flags, params):
if event == cv2.EVENT_LBUTTONDOWN:
#print('Start Mouse Position: ' + str(x) + ', ' + str(y))
sbox = [x, y]
boxes1.append(sbox)
cv2.circle(im, (x, y), radius=0, color=(0, 0, 255), thickness=5)
#print(boxes)
cv2.startWindowThread()
cv2.namedWindow('Select scale', cv2.WND_PROP_FULLSCREEN)
cv2.setMouseCallback('Select scale', on_mouse_0, 0)
while True:
cv2.imshow('Select scale', im)
if cv2.waitKey(10) == 27:
break
cv2.waitKey(1)
cv2.destroyAllWindows()
scale = math.sqrt( ((boxes1[0][0]-boxes1[1][0])**2)+((boxes1[0][1]-boxes1[1][1])**2) )
print(scale)
result = 0
boxes = []
def on_mouse(event, x, y, flags, params):
if event == cv2.EVENT_LBUTTONDOWN:
#print('Start Mouse Position: ' + str(x) + ', ' + str(y))
sbox = [x, y]
boxes.append(sbox)
cv2.circle(im, (x, y), radius=0, color=(0, 0, 255), thickness=5)
#print(boxes)
cv2.startWindowThread()
cv2.namedWindow('Select minimum diameter')
cv2.setMouseCallback('Select minimum diameter', on_mouse, 0)
while True:
cv2.imshow('Select minimum diameter', im)
if cv2.waitKey(10) == 27:
break
cv2.waitKey(1)
cv2.destroyAllWindows()
min_distance = math.sqrt( ((boxes[0][0]-boxes[1][0])**2)+((boxes[0][1]-boxes[1][1])**2) )
print(min_distance)
selector_s = Label(newWindow, text="Deleting irrelevant parts...", font='12')
selector_s.pack()
newWindow.update()
im = metadata_removal(im)
im = eight_bit(im)
gray = grayscale(im)
equ = histogram_equalization(gray)
median = median_filtering(equ)
otsu = otsu_method(median)
border = add_border(otsu)
reverse = reversing(border)
opening = opening_operation(reverse, np.ones((6, 5), np.uint8))
im = closing_operation(opening, np.ones((6, 5), np.uint8))
# list of all images
t0 = time.time()
selector = Label(newWindow, text="> Performing detections...",font = '12')
selector.pack()
newWindow.update()
print('Starting estimations...')
total_x_0 = np.empty((len(im) ,len(im[0])))
total_x_225 = np.empty((len(im) ,len(im[0])))
total_x_45 = np.empty((len(im) ,len(im[0])))
total_y_0 = np.empty((len(im) ,len(im[0])))
total_y_225 = np.empty((len(im), len(im[0])))
total_y_45 = np.empty((len(im), len(im[0])))
indexes_0, indexes_225, indexes_45, indexes, indexes_0_y, indexes_45_y, indexes_225_y, indexes_y = [],[],[],[],[],[],[],[]
total = np.zeros((len(im) ,len(im[0])))
total_y = np.zeros((len(im) ,len(im[0])))
lst_all_diameters, lst_all_diameters_x, lst_all_diameters_y = [],[],[]
for y in range(len(im)):
for x in range(len(im[y])):
if im[y][x]==0:
# X-SCAN#
if im[y][x -1]==255:
# x0 scan
start_0_x = [x,y]
end_0_x = [x,y]
count_0_x = 1
for k in range(x + 1 ,len(im[y])):
if im[y][k] == 0:
end_0_x = [k,y]
count_0_x += 1
else:
total_x_0[y][x] = count_0_x * 500 / scale
indexes_0.append([start_0_x,end_0_x])
break
# x225 scan
count_225_x = 1
start_225_x = [x,y]
end_225_x = [x,y]
for k in range(x + 1 ,len(im[y])):
if im[y+count_225_x][k] == 0:
end_225_x = [k, y+count_225_x]
count_225_x += 1
else:
total_x_225[y][x] = count_225_x * 1.4141 * 500 / scale
indexes_225.append([start_225_x, end_225_x])
break
# x45 scan
count_45_x = 1
start_45_x = [x, y]
end_45_x = [x, y]
for k in range(x + 1, len(im[y])):
if im[y - count_45_x][k] == 0:
end_45_x = [k, y - count_45_x]
count_45_x += 1
else:
total_x_45[y][x] = count_45_x * 1.4141 * 500 / scale
indexes_45.append([start_45_x, end_45_x])
break
# find minimum on X
if ( total_x_225[y][x] <= total_x_0[y][x] ) and ( total_x_225[y][x] <= total_x_45[y][x] ) and ( total_x_225[y][x] > min_distance ):
total[y][x] = total_x_225[y][x]
indexes.append([start_225_x, end_225_x])
lst_all_diameters_x.append(total_x_225[y][x])
lst_all_diameters.append(total_x_225[y][x])
elif ( total_x_0[y][x] <= total_x_225[y][x] ) and ( total_x_0[y][x] <= total_x_45[y][x] ) and ( total_x_0[y][x] > min_distance ):
indexes.append([start_0_x, end_0_x])
total[y][x] = total_x_0[y][x]
lst_all_diameters_x.append(total_x_0[y][x])
lst_all_diameters.append(total_x_0[y][x])
elif (total_x_45[y][x] <= total_x_225[y][x]) and (total_x_45[y][x] <= total_x_0[y][x]) and ( total_x_45[y][x] > min_distance):
indexes.append([start_45_x, end_45_x])
total[y][x] = total_x_45[y][x]
lst_all_diameters_x.append(total_x_45[y][x])
lst_all_diameters.append(total_x_45[y][x])
#Y-SCAN#
if im[y-1][x] == 255:
# y0 scan
start_0_y = [x,y]
end_0_y = [x,y]
count_0_y = 1
for k in range(y + 1 ,len(im)):
if im[k][x] == 0:
end_0_y = [x,k]
count_0_y += 1
else:
total_y_0[y][x] = count_0_y * 500 / scale
indexes_0_y.append([start_0_y,end_0_y])
break
# y225 scan
count_225_y = 1
start_225_y = [x, y]
end_225_y = [x, y]
for k in range(y + 1,len(im)):
if im[k][x - count_225_y] == 0:
end_225_y = [x - count_225_y, k]
count_225_y += 1
else:
total_y_225[y][x] = count_225_y * 1.4141 * 500 / scale
indexes_225_y.append([start_225_y, end_225_y])
break
# y45 scan
count_45_y = 1
start_45_y = [x, y]
end_45_y = [x, y]
for k in range(y + 1,len(im)):
if im[k][x + count_45_y] == 0:
end_45_y = [x + count_45_y, k]
count_45_y += 1
else:
total_y_45[y][x] = count_45_y * 1.4141 * 500 / scale
indexes_45_y.append([start_45_y, end_45_y])
break
# find minimum on Y
if ( total_y_225[y][x] <= total_y_0[y][x] ) and ( total_y_225[y][x] <= total_y_45[y][x] ) and (total_y_225[y][x] > min_distance):
total_y[y][x] = total_y_225[y][x]
indexes_y.append([start_225_y, end_225_y])
lst_all_diameters_y.append(total_y_225[y][x])
lst_all_diameters.append(total_y_225[y][x])
elif ( total_y_0[y][x] <= total_y_225[y][x] ) and ( total_y_0[y][x] <= total_y_45[y][x] ) and (total_y_0[y][x] > min_distance):
indexes_y.append([start_0_y, end_0_y])
total[y][x] = total_y_0[y][x]
lst_all_diameters_y.append(total_y_0[y][x])
lst_all_diameters.append(total_y_0[y][x])
elif ( total_y_45[y][x] <= total_y_225[y][x] ) and ( total_y_45[y][x] <= total_y_0[y][x] ) and (total_y_45[y][x] > min_distance):
indexes_y.append([start_45_y, end_45_y])
total_y[y][x] = total_y_45[y][x]
lst_all_diameters_y.append(total_y_45[y][x])
lst_all_diameters.append(total_y_45[y][x])
t0_1 = time.time()
total_det = t0_1 - t0
selector0 = Label(newWindow, text="Done...", font='12').pack()
newWindow.update()
selector1 =Label(newWindow, text="Time needed for " + str(len(lst_all_diameters)) + " detections: " + str(round(total_det,2)) + " sec \n", font='12').pack()
newWindow.update()
selector2 = Label(newWindow, text="> Calculating diameter...",font = '12').pack()
t1 = time.time()
newWindow.update()
avg = Average(lst_all_diameters)
avg_x = Average(lst_all_diameters_x)
avg_y = Average(lst_all_diameters_y)
print('The average diameter in x axis is: ', avg_x)
print('The average diameter in y axis is: ', avg_y)
print('The average diameter in both axes is: ', avg)
t2 = time.time()
total_calc = t2 - t1
selector3 = Label(newWindow, text="Average cnt diameter is: " + str(round(avg,2)) + "nm", font='12').pack()
newWindow.update()
selector4 = Label(newWindow, text="Time needed for diameter calculation: " + str(round(total_calc,10)) + " sec \n", font='12').pack()
newWindow.update()
t3 = time.time()
selector6 = Label(newWindow, text="> Plotting... ", font='12').pack()
newWindow.update()
print('Starting visualizations...')
#X AXIS visualization#
plt.imshow(im, cmap='gray')
for item in indexes:
x = [item[0][0],item[1][0]]
y = [item[0][1],item[1][1]]
plt.plot(x, y)
plt.xticks([])
plt.yticks([])
plt.title("Detections with Image Processing \n Average diameter in nanometer: " + str(round(avg_x,2)))
plt.draw()
plt.pause(0.001)
input("Press enter to continue...")
plt.close()
# Y AXIS visualization#
plt.imshow(im, cmap='gray')
for item in indexes_y:
x = [item[0][0],item[1][0]]
y = [item[0][1],item[1][1]]
plt.plot(x, y)
plt.xticks([])
plt.yticks([])
plt.title("Detections with Image Processing \n Average diameter in nanometer: " + str(round(avg_y,2)))
plt.draw()
plt.pause(0.001)
input("Press enter to continue...")
plt.close()
plot_hist(lst_all_diameters)
def __init__(self,
rom_file,
viz=0,
frame_skip=4,
nullop_start=30,
live_lost_as_eoe=True,
max_num_frames=0):
"""
Args:
rom_file: path to the rom
frame_skip: skip every k frames and repeat the action
viz: visualization to be done.
Set to 0 to disable.
Set to a positive number to be the delay between frames to show.
Set to a string to be a directory to store frames.
nullop_start: start with random number of null ops.
live_losts_as_eoe: consider lost of lives as end of episode. Useful for training.
max_num_frames: maximum number of frames per episode.
"""
super(AtariPlayer, self).__init__()
if not os.path.isfile(rom_file) and '/' not in rom_file:
rom_file = get_dataset_path('atari_rom', rom_file)
assert os.path.isfile(rom_file), \
"rom {} not found. Please download at {}".format(rom_file, ROM_URL)
try:
ALEInterface.setLoggerMode(ALEInterface.Logger.Error)
except AttributeError:
if execute_only_once():
logger.warn("You're not using latest ALE")
# avoid simulator bugs: https://github.com/mgbellemare/Arcade-Learning-Environment/issues/86
with _ALE_LOCK:
self.ale = ALEInterface()
self.rng = get_rng(self)
self.ale.setInt(b"random_seed", self.rng.randint(0, 30000))
self.ale.setInt(b"max_num_frames_per_episode", max_num_frames)
self.ale.setBool(b"showinfo", False)
self.ale.setInt(b"frame_skip", 1)
self.ale.setBool(b'color_averaging', False)
# manual.pdf suggests otherwise.
self.ale.setFloat(b'repeat_action_probability', 0.0)
# viz setup
if isinstance(viz, six.string_types):
assert os.path.isdir(viz), viz
self.ale.setString(b'record_screen_dir', viz)
viz = 0
if isinstance(viz, int):
viz = float(viz)
self.viz = viz
if self.viz and isinstance(self.viz, float):
self.windowname = os.path.basename(rom_file)
cv2.startWindowThread()
cv2.namedWindow(self.windowname)
self.ale.loadROM(rom_file.encode('utf-8'))
self.width, self.height = self.ale.getScreenDims()
self.actions = self.ale.getMinimalActionSet()
self.live_lost_as_eoe = live_lost_as_eoe
self.frame_skip = frame_skip
self.nullop_start = nullop_start
self.action_space = spaces.Discrete(len(self.actions))
self.observation_space = spaces.Box(low=0,
high=255,
shape=(self.height, self.width),
dtype=np.uint8)
self._restart_episode()
def getit(_width,_height) :
# grab the current frame
camera = cv2.VideoCapture(0)
(grabbed, frame) = camera.read()#parameter1-bool ; Pmtr2-array
# resize the frame, blur it, and convert it to the HSV color space
frame = imutils.resize(frame, width=_width,height=_height)
frame = cv2.flip(frame,1)
blurred = cv2.GaussianBlur(frame, (11, 11), 0)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, greenLower, greenUpper)
mask = cv2.erode(mask, None, iterations=2) #clean up data
mask = cv2.dilate(mask, None, iterations=2) #^
# find contours in the mask and initialize the current (x, y) center of the color mass
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, #Finds blobs of
cv2.CHAIN_APPROX_SIMPLE)[-2]
center = None
# only proceed if at least one contour was found
if len(cnts) > 0:
# find the largest contour in the mask, then use
c = max(cnts, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
# only proceed if the radius meets a minimum size
if radius > 10:
# draw the circle and centroid on the frame,
# then update the list of tracked points
cv2.circle(frame, (int(x), int(y)), int(radius),
(0, 255, 255), 2)
cv2.circle(frame, center, 5, (0, 0, 255), -1)
# update the points queue
pts.appendleft(center)
# loop over the set of tracked points
for i in xrange(1, len(pts)):
# if either of the tracked points are None, ignore
# them
if pts[i - 1] is None or pts[i] is None:
continue
cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), 4)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
return 0
camera.release()
#return(frame,center)
# show the frame to our screen
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
cv2.moveWindow("base-image",0,100)
cv2.moveWindow("result-image",600,100)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
cv2.imshow("base-image", frame)
cv2.imshow("result-image", mask)
def detectAndTrackMultipleFaces():
cam = 'test_out_04.avi'
capture = cv2.VideoCapture(cam)
process_this_frame = True
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
cv2.moveWindow("result-image", 400, 100)
cv2.startWindowThread()
rectangleColor = (0,165,255)
frameCounter = 0
currentFaceID = 0
faceTrackers = {}
faceNames = {}
try:
while True:
rc,fullSizeBaseImage = capture.read()
baseImage = cv2.resize(fullSizeBaseImage, (0,0), fx = 0.6, fy = 0.6)
baseImage = baseImage[:, :, ::-1]
pressedKey = cv2.waitKey(5)
if pressedKey == ord('Q'):
break
resultImage = baseImage.copy()
frameCounter += 1
fidsToDelete = []
for fid in faceTrackers.keys():
trackingQuality = faceTrackers[ fid ].update( baseImage )
if trackingQuality < 7:
fidsToDelete.append( fid )
for fid in fidsToDelete:
print("Removing fid " + str(fid) + " from list of trackers")
faceTrackers.pop( fid , None )
#best param = 6
if (frameCounter % 6) == 0:
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
# y = top
# x = left
# h = bottom - y
# w = right - x
# face_locations = face_recognition.face_locations(baseImage)
face_locations = faceCascade.detectMultiScale(gray, 1.3, 5)
# top, right, bottom, left
fl = []
qwe = 1
for (_x,_y,_w,_h) in face_locations:
if (_w**2 + _h**2)**0.5 < 100:
fl.append((_x,_y,_w,_h))
face_locations = fl
del fl
face_locations = [(_y, _x+_w, _y+_h, _x) for (_x,_y,_w,_h) in face_locations]
face_encodings = face_recognition.face_encodings(baseImage, face_locations)
face_names = []
for face_encoding in face_encodings:
matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
name = "Unknown"
if True in matches:
first_match_index = matches.index(True)
name = known_face_names[first_match_index]
face_names.append(name)
for (top, right, bottom, left), name in zip(face_locations, face_names):
y = top
x = left
h = bottom - y
w = right - x
x_bar = x + 0.5 * w
y_bar = y + 0.5 * h
matchedFid = None
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
#Считаем центр
t_x_bar = t_x + 0.5 * t_w
t_y_bar = t_y + 0.5 * t_h
if ( ( t_x <= x_bar <= (t_x + t_w)) and
( t_y <= y_bar <= (t_y + t_h)) and
( x <= t_x_bar <= (x + w )) and
( y <= t_y_bar <= (y + h ))):
matchedFid = fid
# Если нет трека, делаем новый
if matchedFid is None:
print("Creating new tracker " + str(currentFaceID))
#Create and store the tracker
tracker = dlib.correlation_tracker()
tracker.start_track(baseImage,
dlib.rectangle( x-10,
y-20,
x+w+10,
y+h+20))
faceTrackers[currentFaceID] = tracker
faceNames[currentFaceID] = name
alarm_bool = (name == 'Unknown')
if name != 'Unknown':
status_type = 'student'
else:
status_type = 'Unknown'
act = {'status':status_type,'name':name, 'alarm':str(alarm_bool)}
database.append_action(cam, act)
# Счетчик idшников
currentFaceID += 1
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
top = t_y
bottom = t_y + t_h
right = t_x + t_w
left = t_x
# cv2.rectangle(resultImage, (t_x, t_y),
# (t_x + t_w , t_y + t_h),
# (0,0,255) ,2)
print(faceNames)
cv2.rectangle(resultImage, (left, top), (right, bottom), (0, 0, 255), 2)
cv2.rectangle(resultImage, (left, bottom - 10), (right, bottom), (0, 0, 255), cv2.FILLED)
font = cv2.FONT_HERSHEY_DUPLEX
# cv2.putText(image_full, name, (left + 6, bottom - 6), font, 1.0, (255, 255, 255), 1)
try:
cv2.putText(resultImage, faceNames[fid], (left + 2, bottom - 1), font, 0.4, (255, 255, 255), 1)
except KeyError:
cv2.putText(resultImage, faceNames[fid], (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1)
resultImage = resultImage[:, :, ::-1]
# largeResult = cv2.resize(resultImage,
# (OUTPUT_SIZE_WIDTH,OUTPUT_SIZE_HEIGHT))
# Рисуем
cv2.imshow("result-image", resultImage)
except KeyboardInterrupt as e:
pass
cv2.destroyAllWindows()
exit(0)
def detectAndTrackMultipleFaces(model, imagesize):
#Open the first webcame device
capture = cv2.VideoCapture(0)
#Create two opencv named windows
# cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
# cv2.moveWindow("base-image", 0, 100)
cv2.moveWindow("result-image", 400, 100)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 25)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
flag_to_write_csv = 0
result_age = []
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
try:
time_start = time.time()
while True:
#Retrieve the latest image from the webcam
rc, fullSizeBaseImage = capture.read()
#Resize the image to 320x240
fullSizeBaseImage = cv2.flip(fullSizeBaseImage, 1)
baseImage = fullSizeBaseImage
# baseImage = cv2.resize(fullSizeBaseImage, (1400, 1400));
#Check if a key was pressed and if it was Q, then break
#from the infinite loop
pressedKey = cv2.waitKey(2)
if pressedKey == ord('Q'):
break
#Result image is the image we will show the user, which is a
#combination of the original image from the webcam and the
#overlayed rectangle for the largest face
resultImage = baseImage.copy()
#Increase the framecounter
frameCounter += 1
#Update all the trackers and remove the onges for which the update
#indicated the quality was not good enough
fidsToDelete = []
for fid in faceTrackers.keys():
trackingQuality = faceTrackers[fid].update(baseImage)
#If the tracking quality is good enough, we must delete
if trackingQuality < 10:
fidsToDelete.append(fid)
num_person = len(faceTrackers) - len(fidsToDelete)
for fid in fidsToDelete:
faceTrackers.pop(fid, None)
#Every 10 frames, we will have to determine which faces
#are present in the frame
if (frameCounter % 10) == 0:
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2RGB)
faces = hog_face_detector(gray, 1)
for i, d in enumerate(faces):
x, y, x2, y2, w, h = d.left(), d.top(), d.right() + 1,\
d.bottom() + 1, d.width(), d.height()
#calculate the centerpoint
x_bar = x + 0.5 * w
y_bar = y + 0.5 * h
matchedFid = None
#Now loop over all the trackers and check if the
#centerpoint of the face is within the box of a tracker
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
#calculate th e centerpoint
t_x_bar = t_x + 0.5 * t_w
t_y_bar = t_y + 0.5 * t_h
#check if the centerpoint of the face is within the
#rectangleof a tracker region. Also, the centerpoint
#of the tracker region must be within the region
#detected as a face. If both of these conditions hold
#we have a match
if ((t_x <= x_bar <= (t_x + t_w)) and (t_y <= y_bar <=
(t_y + t_h))
and (x <= t_x_bar <=
(x + w)) and (y <= t_y_bar <= (y + h))):
matchedFid = fid
#If no matched fid, then we have to create a new tracker
if matchedFid is None:
# print("Creating new tracker " + str(currentFceID))
#Create and store the tracker
tracker = dlib.correlation_tracker()
tracker.start_track(baseImage,
dlib.rectangle(x, y, x + w, y + h))
faceTrackers[currentFaceID] = tracker
#Start a new thread that is used to simulate
#face recognition. This is not yet implemented in this
#version :)
t = threading.Thread(target=doRecognizePerson,
args=(faceNames, result_age,
currentFaceID))
t.start()
#Increase the currentFaceID counter
currentFaceID += 1
#tracking
time_wirte_csv = time.time()
if time_wirte_csv - time_start > 3:
flag_to_write_csv = 1
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
image = baseImage[t_y - int(t_h / 2):t_y + t_h - 5,
t_x - 5:t_x + t_w + 5, :]
try:
# if flag_to_write_csv:
cv2.imshow("image", image)
gender, age = predict(model, image, imagesize)
except:
continue
cv2.rectangle(resultImage, (t_x, t_y), (t_x + t_w, t_y + t_h),
rectangleColor, 2)
if fid in faceNames.keys():
result_age[fid].append(age)
if len(result_age[fid]) > 10:
age = Counter(
result_age[fid][-10:-1]).most_common()[0][0]
if flag_to_write_csv:
# print(Counter(result_age[fid]))
# print(result_age)
path_out = "output" + "/{}.csv".format(date.today())
if not os.path.exists(path_out):
gen_csv(path_out)
save_csv(gender, age, path_out)
cv2.putText(
resultImage, " " + label_gender[str(gender)] +
",{}".format(label_age[str(age)]),
(int(t_x + t_w / 5), int(t_y)),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1)
else:
cv2.putText(resultImage, "Detecting...",
(int(t_x + t_w / 2), int(t_y)),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255),
2)
if flag_to_write_csv:
flag_to_write_csv = 0
time_start = time.time()
largeResult = cv2.resize(resultImage,
(OUTPUT_SIZE_WIDTH, OUTPUT_SIZE_HEIGHT))
#Finally, we want to show the images on the screen
# cv2.imshow("base-image", baseImage)
cv2.imshow("result-image", largeResult)
except KeyboardInterrupt as e:
pass
#Destroy any OpenCV windows and exit the application
cv2.destroyAllWindows()
exit(0)
def track(self):
#print("inside track")
count = 0
global temp
cap = cv2.VideoCapture(0)
# Start the window thread for the two windows we are using
cv2.startWindowThread()
# The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
# variables holding the current frame number and the current faceid
frameCounter, currentFaceID = 0, 0
# Variables holding the correlation trackers and the name per faceid
faceTrackers, faceNames, face_locations_len_previous, outputs_len_previous = {}, {}, 0, 0
while True:
tk = []
frameCounter += 1
global c3
global c4
full = timer()
ret, frame = cap.read()
gray_img=cv2.cvtColor(frame,cv2.COLOR_RGB2GRAY)
face_locations=faceCascade.detectMultiScale(gray_img, scaleFactor=1.3,minNeighbors=4,minSize=(40,40))
frame = cv2.flip(frame, 1)
frame = cv2.resize(frame, (1080, 1080))
gray_img =cv2.flip(frame, 1)
gray_img = cv2.resize(frame, (1080, 1080))
face_locations_haar=faceCascade.detectMultiScale(gray_img, scaleFactor=1.3,minNeighbors=4,minSize=(40,40))
face_locations = change_coor(face_locations_haar)
start = timer()
resultImg,faceBoxes=highlightFace(faceNet,frame)
# print("face boxes retrieve karwaama ",timer()-start)
half = timer()
bbox_xywh, cls_conf, cls_ids = self.detector(frame)
if (bbox_xywh is not None) & (frameCounter%2 ==0) :
count, start = 0, timer()
mask = cls_ids == 0
bbox_xywh[:, 3:] *= 1.2
c1 = 0
c2 = 0
cls_conf = cls_conf[mask]
outputs = self.deepsort.update(bbox_xywh, cls_conf, frame)
outputs_length = len(outputs)
#face_locations = face_R(frame)
#print("FUNCTION maa atli waar laagi ", timer()-start)
#face_locations_length = len(face_locations)
face_locations_length=len(face_locations)
print("Total no of person: ",face_locations_length)
#asyncio.get_event_loop().run_until_complete(command_receiver(face_locations_length))
for top, right, bottom, left in face_locations:
cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)
for fc in faceBoxes:
face=frame[max(0,fc[1]-padding):
min(fc[3]+padding,frame.shape[0]-1),max(0,fc[0]-padding)
:min(fc[2]+padding, frame.shape[1]-1)]
blob=cv2.dnn.blobFromImage(face, 1.0, (227,227), MODEL_MEAN_VALUES, swapRB=False)
genderNet.setInput(blob)
genderPreds=genderNet.forward()
gender=genderList[genderPreds[0].argmax()]
#print(f'Gender: {gender}')
## ageNet.setInput(blob)
## agePreds=ageNet.forward()
## age=ageList[agePreds[0].argmax()]
## print(f'Age: {age[1:-1]} years')
if gender=='Male':
#print("Male detected")
c1 = c1+1
elif gender=='Female':
#print("Female detected")
c2 = c2 +1
else:
gender = '0'
for top, right, bottom, left in face_locations:
[x,y] = centre(top,right,bottom,left)
# temp2.append([x,y]) #list of centres for gender
if [x,y] == [0,0] :
[x,y] = 'NA'
else :
info = [[x,y],gender]
tk.append(info)
#print("info",tk)
print('Number of Male detected',c1)
print('Number of Female detected',c2)
temp1 = []
if outputs_length >= outputs_len_previous:
for i in range(len(face_locations)):
t1, t2, t3, t4 = face_locations[i]
temp = centre(t1, t2, t3, t4)
temp1.append(temp)
#print("Centre Coordinmates",temp1)
for i in range(len(outputs)):
if outputs[i][4] not in total_p:
total_p.append(outputs[i][4])
if len(outputs) > 0:
bbox_xyxy = outputs[:, :-1]
identities = outputs[:, -1]
frame = draw_boxes(frame, bbox_xyxy, identities)
start = timer()
if outputs_length >= outputs_len_previous:
#print("yes,andar aavyo")
for i in range(len(outputs)):
if (outputs[i][4] not in nv):
#print("che toh nai")
for j in range(len(temp1)):
a, b, c, d, e = outputs[i]
flag = FindPoint(a, b, c, d, temp1[j][0], temp1[j][1])
if flag == True:
if e not in nv:
#print("navu print karyu")
nv.append(e)
# time.sleep(0.5)
func(temp1[j][0],temp1[j][1],outputs_length,outputs_len_previous,faceBoxes,frame,tk)
## #print("Answer",gender)
if gender=='Male':
c3 = c3+1
elif gender=='Female':
c4 = c4 +1
else:
pass
# print("Add karwaama ", timer()-start)
## print("total maa atlo time", timer()-full)
asyncio.get_event_loop().run_until_complete(command_receiver(outputs_length,face_locations_length,c1,c2,0,0,0,0))
outputs_len_previous = outputs_length
cv2.imshow("frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
asyncio.get_event_loop().run_until_complete(command_receiver(outputs_length,face_locations_length,c1,c2,len(total_p),len(nv),c3,c4))
break
cap.release()
cv2.destroyAllWindows()
return [nv,total_p,c3,c4]
def show_cv2_img_mac():
cv2.startWindowThread()
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.waitKey(1)
def vidRoll(color):
#needed to calculate and test out different values for bgr, such that they
#match the different colors.
lower_blue = np.array([110, 50, 50])
upper_blue = np.array([130, 255, 255])
lower_red = np.array([25, 25, 150])
upper_red = np.array([50, 56, 255])
lower_green = np.array([33, 80, 40])
upper_green = np.array([102, 255, 255])
lower_yellow = np.array([20, 100, 100])
upper_yellow = np.array([30, 255, 255])
startFrame = 50
pointsList = []
dframes = 0
bpm = 0
cap = cv2.VideoCapture(0)
startTime = time.time()
frameNumber = 0 #starts drawing when it hits this number
changedList = []
# while time.time()-startTime<30:
#while True:
rollIt = True
cv2.startWindowThread()
while True:
# Take each frame
_, frame = cap.read()
frameNumber += 1 #increments frame number in order to keep track of time
# Convert BGR to HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
imgray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray, 127, 255, 0)
# Threshold the HSV image to get only blue colors
if color == 'blue':
mask = cv2.inRange(hsv, lower_blue, upper_blue)
if color == 'yellow':
mask = cv2.inRange(hsv, lower_yellow, upper_yellow)
if color == 'red':
mask = cv2.inRange(hsv, lower_red, upper_red)
if color == 'green':
mask = cv2.inRange(hsv, lower_green, upper_green)
#remove background noise
mask = cv2.erode(mask, None, iterations=6) #get rid of all blosb
mask = cv2.dilate(mask, None,
iterations=6) #increase the size back up to original
#find contours can only operate on
currContour = cv2.findContours(mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
#second to last part of find contours
center = None
if len(currContour) > 0:
c = max(currContour, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
if radius > 30:
center = (int(x), int(y))
cv2.circle(frame, center, int(radius), (0, 255, 0), 2)
thickness = int(radius // 4)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(frame, frame, mask=mask)
if center != None:
if frameNumber > startFrame and len(pointsList) == 0:
pointsList.append(center)
elif len(pointsList) > 0:
diffX = abs(pointsList[-1][0] - center[0])
diffY = abs(pointsList[-1][1] - center[1])
if (5 < diffX < 400 and 5 < diffY < 400):
pointsList.append(center)
for i in range(len(pointsList) - 1):
cv2.line(frame, pointsList[i], pointsList[i + 1], (255, 0, 0), 2)
if len(pointsList) > 50:
pointsList = pointsList[1:]
directionChange = 0
try:
if alternateChangeDirection(pointsList):
#print("changed direction%s"%(directionChange))
directionChange += 1
changedList.append(time.time() - startTime)
except:
pass
if len(changedList) > 0 and frameNumber % 20 == 0:
bpm = calculatePace(changedList)
if (len(changedList) > 100):
changedList = changedList[1:]
if frameNumber <= startFrame:
cv2.putText(frame, "Wait to start running", (0, 100),
cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255))
cv2.putText(frame, "Get ready by placing colored object in frame",
(0, 150), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255))
# if frameNumber >startFrame and bpm == 0:
# cv2.putText(frame, "Start Running!", (0, 100), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255))
# counter = time.time()-startTime
# cv2.putText(frame, "countdown: %.2f"%counter, (0, 150), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255))
if bpm != 0:
cv2.putText(frame, "Current Beats per Minute: %s" % (bpm),
(0, 100), cv2.FONT_HERSHEY_PLAIN, 2, (238, 130, 238))
cv2.imshow('frame', frame)
# cv2.imshow('mask',mask)
# cv2.imshow('res',res)
waitTime = 5
if cv2.waitKey(waitTime) & 0xFF == ord('q'):
break
print('quit')
cap.release()
cv2.destroyAllWindows()
return bpm
def main():
"""
Load the network and parse the output.
:return: None
"""
global INFO
global DELAY
global POSE_CHECKED
controller = MouseController()
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = args_parser().parse_args()
logger = log.getLogger()
if args.input == 'cam':
input_stream = 0
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
cap = cv2.VideoCapture(input_stream)
initial_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
initial_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
out = cv2.VideoWriter(os.path.join(args.output_dir, "shopper.mp4"),
cv2.VideoWriter_fourcc(*"MP4V"), fps,
(initial_width, initial_height), True)
frame_count = 0
job_id = 1
progress_file_path = os.path.join(args.output_dir,
'i_progress_' + str(job_id) + '.txt')
infer_time_start = time.time()
if input_stream:
cap.open(args.input)
# Adjust DELAY to match the number of FPS of the video file
DELAY = 1000 / cap.get(cv2.CAP_PROP_FPS)
if not cap.isOpened():
logger.error("ERROR! Unable to open video source")
return
# Initialise the class
if args.cpu_extension:
facedet = FaceDetection(args.facemodel,
args.confidence,
extensions=args.cpu_extension)
posest = HeadPoseEstimation(args.posemodel,
args.confidence,
extensions=args.cpu_extension)
landest = FaceLandmarksDetection(args.landmarksmodel,
args.confidence,
extensions=args.cpu_extension)
gazeest = GazeEstimation(args.gazemodel,
args.confidence,
extensions=args.cpu_extension)
else:
facedet = FaceDetection(args.facemodel, args.confidence)
posest = HeadPoseEstimation(args.posemodel, args.confidence)
landest = FaceLandmarksDetection(args.landmarksmodel, args.confidence)
gazeest = GazeEstimation(args.gazemodel, args.confidence)
# Load the network to IE plugin to get shape of input layer
facedet.load_model()
posest.load_model()
landest.load_model()
gazeest.load_model()
print("loaded models")
ret, frame = cap.read()
while ret:
looking = 0
POSE_CHECKED = False
ret, frame = cap.read()
frame_count += 1
if not ret:
print("checkpoint *BREAKING")
break
if frame is None:
log.error("checkpoint ERROR! blank FRAME grabbed")
break
initial_width = int(cap.get(3))
initial_height = int(cap.get(4))
# Start asynchronous inference for specified request
inf_start_fd = time.time()
# Results of the output layer of the network
coords, frame = facedet.predict(frame)
if args.visualization == "fm":
cv2.startWindowThread()
cv2.namedWindow("preview")
cv2.imshow("preview", frame)
det_time_fd = time.time() - inf_start_fd
if len(coords) > 0:
[xmin, ymin, xmax,
ymax] = coords[0] # use only the first detected face
head_pose = frame[ymin:ymax, xmin:xmax]
inf_start_hp = time.time()
is_looking, pose_angles = posest.predict(head_pose)
if args.visualization == "pm":
cv2.startWindowThread()
cv2.namedWindow("preview")
p = "Pose Angles {}, is Looking? {}".format(
pose_angles, is_looking)
cv2.putText(frame, p, (50, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5,
(255, 255, 255), 1)
cv2.imshow("preview", frame)
if is_looking:
det_time_hp = time.time() - inf_start_hp
POSE_CHECKED = True
print(is_looking)
inf_start_lm = time.time()
coords, f = landest.predict(head_pose)
if args.visualization == "lm":
cv2.startWindowThread()
cv2.namedWindow("preview")
cv2.imshow("preview", f)
frame[ymin:ymax, xmin:xmax] = f
det_time_lm = time.time() - inf_start_lm
[[xlmin, ylmin, xlmax, ylmax], [xrmin, yrmin, xrmax,
yrmax]] = coords
left_eye_image = f[ylmin:ylmax, xlmin:xlmax]
right_eye_image = f[yrmin:yrmax, xrmin:xrmax]
output, gaze_vector = gazeest.predict(left_eye_image,
right_eye_image,
pose_angles)
if args.visualization == "gm":
cv2.startWindowThread()
cv2.namedWindow("preview")
p = "Gaze Vector {}".format(gaze_vector)
cv2.putText(frame, p, (50, 15), cv2.FONT_HERSHEY_COMPLEX,
0.5, (255, 255, 255), 1)
fl = draw_gaze(left_eye_image, gaze_vector)
fr = draw_gaze(right_eye_image, gaze_vector)
f[ylmin:ylmax, xlmin:xlmax] = fl
f[yrmin:yrmax, xrmin:xrmax] = fr
cv2.imshow("preview", f)
if frame_count % 10 == 0:
controller.move(output[0], output[1])
# Draw performance stats
inf_time_message = "Face Inference time: {:.3f} ms.".format(
det_time_fd * 1000)
#
if POSE_CHECKED:
cv2.putText(
frame, "Head pose Inference time: {:.3f} ms.".format(
det_time_hp * 1000), (0, 35), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (255, 255, 255), 1)
cv2.putText(frame, inf_time_message, (0, 15),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 255), 1)
out.write(frame)
if frame_count % 10 == 0:
demoutils.progressUpdate(progress_file_path,
int(time.time() - infer_time_start),
frame_count, video_len)
if args.output_dir:
total_time = time.time() - infer_time_start
with open(os.path.join(args.output_dir, 'stats.txt'), 'w') as f:
f.write(str(round(total_time, 1)) + '\n')
f.write(str(frame_count) + '\n')
facedet.clean()
posest.clean()
landest.clean()
gazeest.clean()
cap.release()
cv2.destroyAllWindows()
out.release()
def _initialize_window(self):
cv2.namedWindow("template", cv2.WINDOW_NORMAL)
cv2.resizeWindow('template', 1280, 720)
cv2.startWindowThread()
"""
Created on Mon Feb 18 21:02:03 2019
@author: student
"""
from cv2 import namedWindow, imread, imshow
from cv2 import waitKey, destroyAllWindows, startWindowThread
from cv2 import blur, Canny, circle
# declare windows you want to display
namedWindow("original")
namedWindow("blur")
namedWindow("canny")
# this is always needed to run the GUI thread
startWindowThread()
img = imread('../blofeld.jpg')
imshow("original", img)
# create a new blurred image:
img2 = blur(img, (7, 7))
# draw on the image:
circle(img2, (100, 100), 30, (255, 0, 255), 5)
# display the image:
imshow("blur", img2)
# Canny is an algorith for edge detection
img3 = Canny(img, 10, 200)
imshow("canny", img3)
# the shape gives you the dimensions
h = img3.shape[0]
w = img3.shape[1]
def main_tmp():
global mouse_button_clicked, selected_centroid
#patient id 192 has a problematic xml file, so it's removed for now
#patient_id_lst = [68,71,72,88,90,91,100,118,124,129,135,137,138,143,149,159,161,162,163,164,165,166,
# 167,168,169,171,173,174,175,176,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
# 193,194,197,198,200,202,203,205,207,210,211,212,213,214,217,220,221,222,223,224,225,
# 226,230,231,232,233,234,235,236,237,239,242,243,244,245,246,247,248,249,250,251,252,253,
# 254,255,256,257,258,260,261,264,265,266,267,268,270,271,272,273,274,275,276,277,278,279,
# 280,281,282,283,285,286,287,288,289,290,314,325,332,377,385,399,405,454,470,493,510,522,543,
# 559,562,568,568,576,580,610,624,766,771,772,811,818,875,921,924,939,965,994,1002,1004]
#patient_id_lst = [332,377,385,399,470,493,559,568,580,610,772,818,939,994,1004]
#patient_id_lst = [162,165,190,203,248,470]
#patient_id_lst = [165,176,178,180,198,202,231,243,266,285,818]
#patient_id_lst = [168,198,200,202,203,212,230,231,245,248,256,270,273,282,283,286,287,288,399,559,580,818]
gt_save_root_path = "C:/Users/tizita/Desktop/CODE/Lung-msc-code/gt/"
patient_id_lst = [72]
for patient_id in patient_id_lst:
print "\n\n Processing patient id %d" % patient_id
xml_dt = LIDCXmlParser(
('C:/Users/tizita/Desktop/CODE/Lung-msc-code/xml_data/%04d.xml') %
patient_id) #trial-xml.xml')
xml_dt.parse()
print xml_dt.xml_header
patient_ct_series = PatientCTSeries(
dt_root_path="C:/Users/tizita/Documents/LIDC/LIDC-IDRI/",
patient_no=patient_id)
patient_ct_series.populate_from_xmlparser(xml_dt)
cv2.namedWindow("LIDC-IDRI")
cv2.setMouseCallback("LIDC-IDRI", mouseClickCallback)
cv2.startWindowThread() #important
for trial in [1, 2]:
print "Round : ", trial
mouse_button_clicked = False
selected_centroid = []
for ct in patient_ct_series.annotated_cts:
if ct.no_consensus_annots() > 0: #if one or more rads agree
clusters = ct.get_nodule_clusters()
cv_mat = ct.draw(rad_indx_lst=range(
len(xml_dt.rad_annotations)),
draw_nodules=True,
draw_small=False,
draw_non=False)
for cluster in clusters:
cvx_hull = cluster.convex_hull_with_margin
#cv2.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]])#
cv2.rectangle(img=cv_mat,
pt1=cvx_hull[0],
pt2=cvx_hull[3],
color=(0, 255, 0),
thickness=1)
cv2.imshow('LIDC-IDRI', cv_mat)
ky = cv2.waitKey(0)
if ky == 27: #Esc key
cv2.waitKey(1)
cv2.destroyAllWindows()
#cv2.waitKey(1)
break
if (mouse_button_clicked):
#create a directory in the root path
dst_path = "%s/gt%04d/" % (gt_save_root_path, patient_id)
if not os.path.exists(dst_path):
os.makedirs(dst_path)
fo = open("%s/centroid.txt" % dst_path, "w")
fo.write("%d\n" % len(selected_centroid))
for (x, y) in selected_centroid:
fo.write("%d,%d\n" % (x, y))
fo.close()
print "[%d] cluster centroid(s) defined...processing data.." % len(
selected_centroid)
for indx, ct in enumerate(patient_ct_series.annotated_cts):
if ct.no_consensus_annots() > 0:
ct.save_nearest_cluster(selected_centroid, indx,
dst_path)
print "Finished processing patient id %d" % patient_id
def camera_recognition(test_folder_path='../default_picture_labels'):
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(
'../resources/shape_predictor_68_face_landmarks.dat')
# 创建cv2摄像头对象
cap = cv2.VideoCapture(0)
# cap.set(proID,value)
# 设置视频参数，propId设置的视频参数，value设置的参数值
cap.set(3, 480)
# 截图screenshoot的计数器
cnt_ss = 0
# 人脸截图的计数器
cnt_p = 0
# 保存
path_save = r"../camera_photo/"
# cap.isOpened() 返回true/false检查初始化是否成功
while cap.isOpened():
# cap.read()
# 返回两个值:
# 一个布尔值true/false，用来判断读取视频是否成功/是否到视频末尾
# 图像对象，图像的三维矩阵q
flag, im_rd = cap.read()
# 每帧数据延时1ms，延时为0读取的是静态帧
kk = cv2.waitKey(1)
# 取灰度
img_gray = cv2.cvtColor(im_rd, cv2.COLOR_RGB2GRAY)
# 人脸数rects
rects = detector(img_gray, 0)
# print(len(rects))
# 设置接下来的字体
font = cv2.FONT_HERSHEY_SIMPLEX
if len(rects) != 0:
# 检测到人脸
# 第一个参数 ret 的值为 True 或 False，代表有没有读到图片。第二个参数是 frame，是当前截取一帧的图片
ret, frame = cap.read()
if kk == ord('s'):
cnt_p += 1
cv2.imwrite(path_save + "img_face_" + str(cnt_p) + ".jpg",
frame)
print("Write to local：",
path_save + "img_face_" + str(cnt_p) + ".jpg")
# 矩形框
for k, d in enumerate(rects):
# 计算矩形大小
# pos_start = tuple([d.left(), d.top()])
# pos_end = tuple([d.right(), d.bottom()])
# 计算矩形框大小
height = d.bottom() - d.top()
width = d.right() - d.left()
# 根据人脸大小生成空的图像
cv2.rectangle(im_rd, tuple([d.left(), d.top()]),
tuple([d.right(), d.bottom()]), (0, 255, 255), 2)
# im_blank = np.zeros((height, width, 3), np.uint8)
#
# # 按下's'保存摄像头中的人脸到本地
# if kk == ord('s'):
# cnt_p += 1
# for ii in range(height):
# for jj in range(width):
# im_blank[ii][jj] = im_rd[d.top() + ii][d.left() + jj]
# # 存储人脸图像文件
# cv2.imwrite(path_save + "img_face_" + str(cnt_p) + ".jpg", im_blank)
# print("写入本地：", path_save + "img_face_" + str(cnt_p) + ".jpg")
# 显示人脸数
cv2.putText(im_rd, "faces:" + str(len(rects)), (20, 50), font, 1,
(0, 0, 255), 1, cv2.LINE_AA)
else:
# 没有检测到人脸
cv2.putText(im_rd, "no face", (20, 50), font, 1, (0, 0, 255), 1,
cv2.LINE_AA)
# 添加说明
im_rd = cv2.putText(im_rd, "s: save face", (20, 400), font, 0.8,
(255, 255, 255), 1, cv2.LINE_AA)
im_rd = cv2.putText(im_rd, "q:quit", (20, 450), font, 0.8,
(255, 255, 255), 1, cv2.LINE_AA)
# 按下q键退出
if kk == ord('q'):
break
cv2.startWindowThread()
cv2.imshow("camera", im_rd)
# 窗口显示
# cv2.namedWindow("camera", 0) # 摄像头窗口大小可调
# 释放摄像
cap.release()
cv2.destroyWindow('camera')
# 删除窗口
# 这里用数据库识别
answer = recognition(path_save + "img_face_" + str(cnt_p) + ".jpg",
test_folder_path=test_folder_path,
threshold=0.6,
answer_pic=True)
return answer
def detectAndTrackMultipleFaces():
global block
#Open the first webcame device
capture = cv2.VideoCapture(0)
capture.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0)
capture.set(cv2.CAP_PROP_EXPOSURE, 0.15)
#Create two opencv named windows
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
cv2.moveWindow("base-image", 0, 100)
cv2.moveWindow("result-image", 400, 100)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
faceFeatures = {}
cur_photo = None
try:
while True:
#Retrieve the latest image from the webcam
rc, fullSizeBaseImage = capture.read()
cur_photo = fullSizeBaseImage.copy()
#Resize the image to 320x240
baseImage = cv2.resize(fullSizeBaseImage, (320, 240))
#Check if a key was pressed and if it was Q, then break
#from the infinite loop
pressedKey = cv2.waitKey(2)
if pressedKey == ord('Q'):
break
#Result image is the image we will show the user, which is a
#combination of the original image from the webcam and the
#overlayed rectangle for the largest face
resultImage = baseImage.copy()
#STEPS:
# * Update all trackers and remove the ones that are not
# relevant anymore
# * Every 10 frames:
# + Use face detection on the current frame and look
# for faces.
# + For each found face, check if centerpoint is within
# existing tracked box. If so, nothing to do
# + If centerpoint is NOT in existing tracked box, then
# we add a new tracker with a new face-id
#Increase the framecounter
frameCounter += 1
#Update all the trackers and remove the ones for which the update
#indicated the quality was not good enough
fidsToDelete = []
for fid in faceTrackers.keys():
trackingQuality = faceTrackers[fid].update(baseImage)
#If the tracking quality is good enough, we must delete
#this tracker
if trackingQuality < 7:
fidsToDelete.append(fid)
for fid in fidsToDelete:
print("Removing fid " + str(fid) + " from list of trackers")
faceTrackers.pop(fid, None)
#Every 10 frames, we will have to determine which faces
#are present in the frame
if (frameCounter % 10) == 0:
#For the face detection, we need to make use of a gray
#colored image so we will convert the baseImage to a
#gray-based image
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
#Now use the haar cascade detector to find all faces
#in the image
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
#Loop over all faces and check if the area for this
#face is the largest so far
#We need to convert it to int here because of the
#requirement of the dlib tracker. If we omit the cast to
#int here, you will get cast errors since the detector
#returns numpy.int32 and the tracker requires an int
for (_x, _y, _w, _h) in faces:
x = int(_x)
y = int(_y)
w = int(_w)
h = int(_h)
#calculate the centerpoint
x_bar = x + 0.5 * w
y_bar = y + 0.5 * h
#Variable holding information which faceid we
#matched with
matchedFid = None
#Now loop over all the trackers and check if the
#centerpoint of the face is within the box of a
#tracker
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
#calculate the centerpoint
t_x_bar = t_x + 0.5 * t_w
t_y_bar = t_y + 0.5 * t_h
#check if the centerpoint of the face is within the
#rectangleof a tracker region. Also, the centerpoint
#of the tracker region must be within the region
#detected as a face. If both of these conditions hold
#we have a match
if ((t_x <= x_bar <= (t_x + t_w)) and (t_y <= y_bar <=
(t_y + t_h))
and (x <= t_x_bar <=
(x + w)) and (y <= t_y_bar <= (y + h))):
matchedFid = fid
#If no matched fid, then we have to create a new tracker
if matchedFid is None:
#TODO
print("Creating new tracker " + str(currentFaceID))
print('call')
cv2.imwrite('./imgs/frame.jpg', cur_photo)
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
features = fe.parse_frame(cur_photo)
print(features)
#Create and store the tracker
tracker = dlib.correlation_tracker()
tracker.start_track(
baseImage,
dlib.rectangle(x - 10, y - 20, x + w + 10,
y + h + 20))
faceTrackers[currentFaceID] = tracker
faceFeatures[currentFaceID] = features
#Start a new thread that is used to simulate
#face recognition. This is not yet implemented in this
#version :)
t = threading.Thread(target=doRecognizePerson,
args=(faceNames, currentFaceID))
t.start()
#Increase the currentFaceID counter
currentFaceID += 1
#Now loop over all the trackers we have and draw the rectangle
#around the detected faces. If we 'know' the name for this person
#(i.e. the recognition thread is finished), we print the name
#of the person, otherwise the message indicating we are detecting
#the name of the person
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
cv2.rectangle(resultImage, (t_x, t_y), (t_x + t_w, t_y + t_h),
rectangleColor, 2)
if fid in faceNames.keys():
if faceFeatures[fid] == None and not block:
print('call')
block = True
rc, fullSizeBaseImage = capture.read()
features = FeatureExtraction().parse_frame(
fullSizeBaseImage)
faceFeatures[fid] = features
if faceFeatures[fid] != None:
base = faceFeatures[fid][0]['attributes']
# print(base)
counter = 0
for key in base.keys():
string = ""
string += key + ' : '
string += str(base[key]['value'])
string += ','
cv2.putText(
resultImage, string,
(int(t_x + t_w / 2), int(t_y - counter * 10)),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255),
1)
counter += 1
# cv2.putText(resultImage, faceNames[fid] ,
# (int(t_x + t_w/2), int(t_y)),
# cv2.FONT_HERSHEY_SIMPLEX,
# 0.5, (255, 255, 255), 2)
else:
cv2.putText(resultImage, "Detecting...",
(int(t_x + t_w / 2), int(t_y)),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255),
2)
#Since we want to show something larger on the screen than the
#original 320x240, we resize the image again
#
#Note that it would also be possible to keep the large version
#of the baseimage and make the result image a copy of this large
#base image and use the scaling factor to draw the rectangle
#at the right coordinates.
largeResult = cv2.resize(resultImage,
(OUTPUT_SIZE_WIDTH, OUTPUT_SIZE_HEIGHT))
#Finally, we want to show the images on the screen
# cv2.imshow("base-image", baseImage)
cv2.imshow("base-image", resultImage)
cv2.imshow("result-image", largeResult)
#To ensure we can also deal with the user pressing Ctrl-C in the console
#we have to check for the KeyboardInterrupt exception and break out of
#the main loop
except KeyboardInterrupt as e:
pass
#Destroy any OpenCV windows and exit the application
cv2.destroyAllWindows()
exit(0)
class VideoTracker(object):
def __init__(self, cfg):
use_cuda = torch.cuda.is_available()
self.detector = build_detector(cfg, use_cuda=False)
self.deepsort = build_tracker(cfg, use_cuda=False)
self.class_names = self.detector.class_names
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
if exc_type:
print(exc_type, exc_value, exc_traceback)
def doRecognizePerson(
faceNames, fid
): #------------------------------------------------------------------------------
time.sleep(2)
faceNames[fid] = "Person " + str(
fid
) #-----------------------------------------------------------------------------
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
def track(self):
count = 0
global temp
cap = cv2.VideoCapture(0)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
while True:
global c3
global c4
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
Width = frame.shape[1]
Height = frame.shape[0]
blob = cv2.dnn.blobFromImage(frame,
1.0 / 255.0, (416, 416), [0, 0, 0],
True,
crop=False)
net.setInput(blob)
outs = net.forward(getOutputsNames(net))
c1 = 0 #real-time female count
c2 = 0 #real-time male count
class_ids = []
confidences = []
boxes = []
conf_threshold = 0.5
nms_threshold = 0.4
for out in outs:
#print(out.shape)
for detection in out:
#each detection has the form like this [center_x center_y width height obj_score class_1_score class_2_score ..]
scores = detection[5:] #classes scores starts from index 5
class_id = np.argmax(scores)
confidence = scores[class_id]
if confidence > 0.5:
#print("confidence",confidence)
center_x = int(detection[0] * Width)
center_y = int(detection[1] * Height)
w = int(detection[2] * Width)
h = int(detection[3] * Height)
x = center_x - w / 2
y = center_y - h / 2
class_ids.append(class_id)
print("class_ids", class_ids)
confidences.append(float(confidence))
#print("confidences",confidences)
boxes.append([x, y, w, h])
# apply non-maximum suppression algorithm on the bounding boxes
indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold,
nms_threshold)
for i in indices:
i = i[0]
box = boxes[i]
x = box[0]
y = box[1]
w = box[2]
h = box[3]
if class_ids[i] == 0 or class_ids[i] == 3 or class_ids[
i] == 5 or class_ids[i] == 7:
c1 = c1 + 1
elif class_ids[i] == 1 or class_ids[i] == 2 or class_ids[
i] == 4 or class_ids[i] == 6:
c2 = c2 + 1
else:
pass
print("Num of live female viewers:", c1)
print("Num of live male viewers:", c2)
draw_pred(frame, class_ids[i], confidences[i], round(x),
round(y), round(x + w), round(y + h))
face_locations = face_recognition.face_locations(frame)
#for top, right, bottom, left in face_locations:
# cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
#----------------------------------------------------------------
frameCounter += 1 #------------------------------------------------------------------------------
start = time.time()
bbox_xywh, cls_conf, cls_ids = self.detector(frame)
if bbox_xywh is not None:
#print("No of live viewers: ",len(face_locations))
count = 0
mask = cls_ids == 0
bbox_xywh[:,
3:] *= 1.2 # bbox dilation just in case bbox too small
cls_conf = cls_conf[mask]
outputs = self.deepsort.update(bbox_xywh, cls_conf,
frame) #left,top,right,bottom
face_locations = face_recognition.face_locations(frame)
#print("fl",face_locations)
#for top, right, bottom, left in face_locations:
# cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) #for face detector box
print("No of live viewers: ", len(face_locations))
temp1 = []
for i in range(len(face_locations)):
t1, t2, t3, t4 = face_locations[i]
temp = centre(t1, t2, t3, t4)
temp1.append(temp)
#print("Outputs: ",outputs)
#print(len(outputs))
for i in range(len(outputs)):
if outputs[i][4] not in total_p:
total_p.append(outputs[i][4])
#print(temp)
print("Total No of people: ", len(outputs))
# draw boxes for visualization
if len(outputs) > 0:
bbox_xyxy = outputs[:, :-1]
identities = outputs[:, -1]
frame = draw_boxes(frame, bbox_xyxy,
identities) #for tracker box
for i in range(len(outputs)):
if (outputs[i][4] not in nv):
for j in range(len(temp1)):
a, b, c, d, e = outputs[i]
flag = FindPoint(a, b, c, d, temp1[j][0],
temp1[j][1])
#print(flag)
if flag:
if e not in nv:
nv.append(e)
time.sleep(4)
if class_ids[i] == 0 or class_ids[
i] == 3 or class_ids[
i] == 5 or class_ids[i] == 7:
c4 = c4 + 1
elif class_ids[i] == 1 or class_ids[
i] == 2 or class_ids[
i] == 4 or class_ids[i] == 6:
c3 = c3 + 1
else:
pass
end = time.time()
print("time: {:.03f}s, fps: {:.03f}".format(
end - start, 1 / (end - start)))
cv2.imshow("frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
#print(count)
cap.release()
cv2.destroyAllWindows()
return [nv, total_p, c3, c4]
def connect(self):
self.serial.open()
while not self.isImageStart():
pass
print("finish init camera")
cv2.startWindowThread()
class VideoTracker(object):
def __init__(self, cfg):
use_cuda = torch.cuda.is_available()
if not use_cuda:
raise UserWarning("Running in cpu mode!")
self.detector = build_detector(cfg, use_cuda=True)
self.deepsort = build_tracker(cfg, use_cuda=True)
self.class_names = self.detector.class_names
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
if exc_type:
print(exc_type, exc_value, exc_traceback)
def doRecognizePerson(faceNames, fid):
time.sleep(2)
faceNames[fid] = "Person " + str(fid)
# Start the window thread for the two windows we are using
cv2.startWindowThread()
# The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
# variables holding the current frame number and the current faceid
frameCounter, currentFaceID = 0, 0
# Variables holding the correlation trackers and the name per faceid
faceTrackers, faceNames = {}, {}
def track(self):
print("inside track")
outputs_length = 0
count = 0
global temp
cap = cv2.VideoCapture(0)
# Start the window thread for the two windows we are using
cv2.startWindowThread()
# The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
# variables holding the current frame number and the current faceid
frameCounter, currentFaceID = 0, 0
# Variables holding the correlation trackers and the name per faceid
faceTrackers, faceNames, face_locations_len_previous, outputs_len_previous = {}, {}, 0, 0
while True:
global c3
global c4
full = timer()
ret, frame = cap.read()
gray_img = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
face_locations = faceCascade.detectMultiScale(gray_img,
scaleFactor=1.3,
minNeighbors=4,
minSize=(40, 40))
frame = cv2.flip(frame, 1)
frame = cv2.resize(frame, (1080, 1080))
gray_img = cv2.flip(frame, 1)
gray_img = cv2.resize(frame, (1080, 1080))
face_locations_haar = faceCascade.detectMultiScale(gray_img,
scaleFactor=1.3,
minNeighbors=4,
minSize=(40,
40))
face_locations = change_coor(face_locations_haar)
frameCounter += 1
half = timer()
bbox_xywh, cls_conf, cls_ids = self.detector(frame)
resultImg, faceBoxes = highlightFace(faceNet, frame)
#if(outputs_length==0):
# ws.send(json.dumps({'users_count': 0})) #'current_users':face_locations_length,'male_users':c1,'female_users':c2}))#'total_users_count':total_p,'total_current_users':nv,'total_male_users':c3,'total_female_users':c4}))
#outputs = self.deepsort.update(bbox_xywh, cls_conf, frame)
## if (bbox_xywh is None)==0:
## ws.send(json.dumps({'users_count': 0}))
if (bbox_xywh is not None) & (frameCounter % 1 == 0):
count, start = 0, timer()
mask = cls_ids == 0
bbox_xywh[:, 3:] *= 1.2
c1 = 0
c2 = 0
cls_conf = cls_conf[mask]
start = timer()
outputs = self.deepsort.update(bbox_xywh, cls_conf, frame)
outputs_length = len(outputs)
print("output length: ", outputs_length)
start = timer()
if outputs_length < 1:
ws.send(
json.dumps({
'users_count': 0,
'current_users': 0,
'male_users': c1,
'female_users': c2
})
) #'total_users_count':total_p,'total_current_users':nv,'total_male_users':c3,'total_female_users':c4}))
#face_locations = face_R(frame)
#print("FUNCTION maa atli waar laagi ", timer()-start)
#face_locations_length = len(face_locations)
face_locations_length = len(face_locations)
#if(face_locations_length)==0:
# ws.send(json.dumps({'users_count': outputs_length,'current_users':face_locations_length,'male_users':c1,'female_users':c2}))#'total_users_count':total_p,'total_current_users':nv,'total_male_users':c3,'total_female_users':c4}))
start = timer()
for top, right, bottom, left in face_locations:
cv2.rectangle(frame, (left, top), (right, bottom),
(0, 255, 0), 2)
for fc in faceBoxes:
face = frame[max(0, fc[1] -
padding):min(fc[3] +
padding, frame.shape[0] - 1),
max(0, fc[0] -
padding):min(fc[2] +
padding, frame.shape[1] - 1)]
blob = cv2.dnn.blobFromImage(face,
1.0, (227, 227),
MODEL_MEAN_VALUES,
swapRB=False)
genderNet.setInput(blob)
genderPreds = genderNet.forward()
gender = genderList[genderPreds[0].argmax()]
if gender == 'Male':
#print("Male detected")
c1 = c1 + 1
elif gender == 'Female':
#print("Female detected")
c2 = c2 + 1
## for top, right, bottom, left in face_locations:
## [x,y] = centre(top,right,bottom,left)
## # temp2.append([x,y]) #list of centres for gender
## if [x,y] == [0,0] :
## [x,y] = 'NA'
## else :
## info = [[x,y],gender]
## tk.append(info)
#print("info",tk)
print('Number of Male detected', c1)
print('Number of Female detected', c2)
temp1 = []
start = timer()
if outputs_length >= outputs_len_previous:
for i in range(len(face_locations)):
t1, t2, t3, t4 = face_locations[i]
temp = centre(t1, t2, t3, t4)
temp1.append(temp)
#print("Centre Coordinmates",temp1)
for i in range(len(outputs)):
if outputs[i][4] not in total_p:
total_p.append(outputs[i][4])
start = timer()
if len(outputs) > 0:
bbox_xyxy = outputs[:, :-1]
identities = outputs[:, -1]
frame = draw_boxes(frame, bbox_xyxy, identities)
start = timer()
if outputs_length >= outputs_len_previous:
#print("yes,andar aavyo")
for i in range(len(outputs)):
if (outputs[i][4] not in nv):
#print("che toh nai")
for j in range(len(temp1)):
a, b, c, d, e = outputs[i]
flag = FindPoint(a, b, c, d, temp1[j][0],
temp1[j][1])
if flag == True:
if e not in nv:
# print("navu print karyu")
nv.append(e)
gen = func(temp1[j][0], temp1[j][1],
outputs_length,
outputs_len_previous,
faceBoxes, frame)
## #print("Answer",gender)
time.sleep(1)
if gen == 'Male':
c3 = c3 + 1
elif gen == 'Female':
c4 = c4 + 1
else:
gen = None
else:
#print("print nai thaay")
pass
#asyncio.get_event_loop().run_until_complete(command_receiver(outputs_length,face_locations_length,c1,c2,0,0,0,0))
ws.send(
json.dumps({
'users_count': outputs_length,
'current_users': face_locations_length,
'male_users': c1,
'female_users': c2
})
) #'total_users_count':total_p,'total_current_users':nv,'total_male_users':c3,'total_female_users':c4}))
outputs_len_previous = outputs_length
else:
ws.send(json.dumps({'users_count': 0}))
cv2.imshow("frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
#asyncio.get_event_loop().run_until_complete(command_receiver(outputs_length,face_locations_length,c1,c2,len(total_p),len(nv),c3,c4))
ws.send(
json.dumps({
'users_count': outputs_length,
'current_users': face_locations_length,
'male_users': c1,
'female_users': c2,
'total_users_count': len(total_p),
'total_current_users': len(nv),
'total_male_users': c3,
'total_female_users': c4
}))
#ws.send(json.dumps({'users_count': outputs_length,'current_users':face_locations_length,'male_users':c1,'female_users':c2}))
ws.close()
break
cap.release()
cv2.destroyAllWindows()
return [nv, total_p, c3, c4]
def run_ml(self):
return self.track()
def init_opencv():
cv2.startWindowThread()
import sys
import FindResult
reload(sys)
sys.setdefaultencoding('utf8')
cap = cv2.VideoCapture(0)
cap.set(3, 1920)
cap.set(4, 1080)
cap.set(1, 10.0)
while cap.isOpened():
isSuccess, frame = cap.read()
if isSuccess:
cv2.namedWindow('myCapture', 0)
cv2.startWindowThread() #加在这个位置
cv2.imshow("myCapture", frame)
cv2.imwrite("opencvPic.jpeg", frame)
time.sleep(0.1)
ocr = OCR()
text = ocr.startWithFile('opencvPic.jpeg')
print text
if text:
if len(text) > 3:
FindResult.FindShowBaidu(text)
time.sleep(0.2)
if cv2.waitKey(1) & 0xff == ord('q'):
cv2.imwrite("opencvPic.jpeg", frame)
cap.release()
def track(self):
count = 0
global temp
#import url
import numpy as np
import cv2
#Create two opencv named windows
#cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE) #--------------------------------------------------------------
# cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE) #--------------------------------------------------------------
#Position the windows next to eachother
#cv2.moveWindow("base-image",0,100) #--------------------------------------------------------------
#cv2.moveWindow("result-image",400,100) #---------------------------------------------------------------
#cap = cv2.VideoCapture('http://192.168.137.61:80/')#.dtype('uint32')
cap = cv2.VideoCapture(0)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
while True:
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
frame = cv2.resize(frame, (1080, 1080))
#baseImage = cv2.resize( frame, ( 1080, 1080)) #-------------------------------------------------------
#frame = baseImage[:, :, ::-1]
face_locations = face_recognition.face_locations(frame)
#print("Face location: ",face_locations)
#for top, right, bottom, left in face_locations:
# cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
#resultImage = baseImage.copy() #----------------------------------------------------------------
frameCounter += 1 #------------------------------------------------------------------------------
bbox_xywh, cls_conf, cls_ids = self.detector(frame)
#cv2.putText(frame,str(bbox_xywh),(0,15), cv2.FONT_HERSHEY_PLAIN,1,(255,255,255) ,2)
if bbox_xywh is not None:
#print("No of live viewers: ",len(face_locations))
count = 0
#print("Centre of face",temp)
#print("Face loactions "+str(face_locations)+"Person: "+str(bbox_xywh))
#flag=1
mask = cls_ids == 0
bbox_xywh[:,
3:] *= 1.2 # bbox dilation just in case bbox too small
cls_conf = cls_conf[mask]
outputs = self.deepsort.update(bbox_xywh, cls_conf,
frame) #left,top,right,bottom
face_locations = face_recognition.face_locations(frame)
for top, right, bottom, left in face_locations:
cv2.rectangle(frame, (left, top), (right, bottom),
(0, 0, 255), 2)
print("No of live viewers: ", len(face_locations))
temp1 = []
for i in range(len(face_locations)):
t1, t2, t3, t4 = face_locations[i]
temp = centre(t1, t2, t3, t4)
temp1.append(temp)
#print("Outputs: ",outputs)
#print(len(outputs))
for i in range(len(outputs)):
if outputs[i][4] not in total_p:
total_p.append(outputs[i][4])
#print(temp)
print("Total No of people: ", len(outputs))
# draw boxes for visualization
if len(outputs) > 0:
bbox_xyxy = outputs[:, :-1]
identities = outputs[:, -1]
frame = draw_boxes(frame, bbox_xyxy, identities)
for i in range(len(outputs)):
if (outputs[i][4] not in nv):
for j in range(len(temp1)):
a, b, c, d, e = outputs[i]
flag = FindPoint(a, b, c, d, temp1[j][0],
temp1[j][1])
#print(flag)
if flag:
if e not in nv:
nv.append(e)
#print("nv",nv)
cv2.imshow("frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
#print(count)
cap.release()
cv2.destroyAllWindows()
#print("No of People detected : ",len(temp))
#print(temp)
return [nv, total_p]
def undistort_movie(self, ofnam=None, frameint=25, crf=12, write=True, display=True, tmp_dir=None, crop=False):
if self.movie is None:
raise ArgusError('no movie specified')
if (self.omni is None) and (self.coefficients is None):
raise ArgusError('no distortion coefficients specified')
if tmp_dir is None:
tmp = tempfile.mkdtemp()
else:
tmp = tmp_dir
print(tmp)
print('Ripping audio... \n')
sys.stdout.flush()
cmd = [
get_setting("FFMPEG_BINARY"),
'-loglevel', 'panic',
'-hide_banner',
'-i', self.infilename,
'-c:a', 'copy',
'-vn', '-sn',
tmp + '/' + 'temp.m4a']
subprocess.call(cmd)
if os.path.exists(tmp + '/' + 'temp.m4a'):
statinfo = os.stat(tmp + '/' + 'temp.m4a')
if statinfo.st_size != 0:
audio = tmp + '/' + 'temp.m4a'
else:
audio = None
else:
audio = None
if audio is not None:
cmd = [get_setting("FFMPEG_BINARY"), '-y', '-f', 'rawvideo', \
'-vcodec', 'rawvideo', '-s', '{0}x{1}'.format(self.w, self.h), '-pix_fmt', 'rgb24', \
'-r', str(self.fps), '-i', '-', '-i', audio, \
'-acodec', 'copy', '-vcodec', 'libx264', '-preset', 'medium', '-crf', \
str(crf), '-g', str(frameint), '-pix_fmt', 'yuv420p', '-profile', 'baseline', '-threads', \
'0', '-pix_fmt', 'yuv420p', str(ofnam)]
else:
cmd = [get_setting("FFMPEG_BINARY"), '-y', '-f', 'rawvideo', \
'-vcodec', 'rawvideo', '-s', '{0}x{1}'.format(self.w, self.h), '-pix_fmt', 'rgb24', \
'-r', str(self.fps), '-i', '-', '-an', \
'-acodec', 'copy', '-vcodec', 'libx264', '-preset', 'medium', '-crf', \
str(crf), '-g', str(frameint), '-pix_fmt', 'yuv420p', '-profile', 'baseline', '-threads', \
'0', '-pix_fmt', 'yuv420p', str(ofnam)]
if write:
if ofnam == '':
raise ArgusError('no output filename specified')
_ = ofnam.split('.')
if _[len(_) - 1] != 'mp4' and _[len(_) - 1] != 'MP4':
raise ArgusError('output filename must specify an mp4 file')
return
if os.path.isfile(ofnam):
raise ArgusError('output file already exists! Argus will not overwrite')
return
try:
t = open(self.infilename, "r")
except:
raise ArgusError('input movie not found')
return
t = None
if not self.coefficients is None:
map1, map2 = self.get_mappings(crop)
# if we're displaying, make a window to do so
print('Beginning to undistort images and compile with FFMPEG...')
sys.stdout.flush()
p = Popen(cmd, stdin=PIPE)
if display:
if 'linux' in sys.platform:
cv2.imshow("Undistorted", np.zeros((1080, 1920, 3)))
cv2.namedWindow("Undistorted")
if write:
# Create a list of the frames (pngs)
fileList = []
k = 1
if display:
if not 'linux' in sys.platform:
cv2.startWindowThread()
for a in range(int(self.movie.get(cv2.CAP_PROP_FRAME_COUNT))):
retval, raw = self.movie.read()
if retval:
previous = raw
if crop:
if self.oCamUndistorter is None:
undistorted = cv2.remap(raw, map1, map2, cv2.INTER_LINEAR)
else:
undistorted = self.oCamUndistorter.undistort_frame(raw)
else:
if self.oCamUndistorter is None:
undistorted = cv2.remap(raw, map1, map2,
interpolation=cv2.INTER_CUBIC,
borderMode=cv2.BORDER_CONSTANT,
borderValue=(211, 160, 86))
else:
undistorted = self.oCamUndistorter.undistort_frame(raw)
if display:
cv2.imshow('Undistorted', cv2.resize(undistorted, (0, 0), fx=0.5, fy=0.5))
cv2.waitKey(1)
undistorted = cv2.cvtColor(undistorted, cv2.COLOR_BGR2RGB)
# im = Image.fromarray(undistorted, 'RGB')
# im.save(p.stdin, 'PNG')
if write:
p.stdin.write(undistorted.tostring())
# line of code above allows you to open video clip after it is saved
# without that line video clip will save but won't be able to open and play clip
variable = False
self.root = Tk()
def __init__(self, master, title):
top = self.top = Toplevel(master)
top.resizable(width=FALSE, height=FALSE)
top.bind('<Return>', self.cleanup)
self.l = Label(top, text=title)
self.l.pack(padx=10, pady=10)
self.e = Entry(top)
self.e.focus_set()
self.e.pack(padx=10, pady=5)
self.b = Button(top, text='Ok', padx=10, pady=10)
self.b.bind('<Button-1>', self.cleanup)
self.b.pack(padx=5, pady=5)
self.crop = StringVar(self.root)
self.copy = StringVar(self.root)
self.wrdispboth = IntVar(self.root)
if a % 5 == 0:
print('\n', end='')
sys.stdout.flush()
"""
# Write the individual frame as a png to the temporary directory
if write:
cv2.imwrite(tmp + '/' + str(a) + '.png', undistorted)
fileList.append(tmp + '/' + str(a) + '.png')
"""
else:
if write:
print("Could not read frame number: " + str(a) + "\n writing blank frame")
p.stdin.write(np.zeros_like(previous).tostring())
sys.stdout.flush()
else:
print("Could not read frame number: " + str(a))
sys.stdout.flush()
p.stdin.close()
p.wait()
print('Undistortion finished')
if write:
print('Wrote mp4 to {0}'.format(ofnam))
sys.stdout.flush()
# Destroy movie object and the window if it was even created
movie = None
if display:
cv2.waitKey(1)
cv2.destroyAllWindows()
cv2.waitKey(1)
if write:
# clip = ImageSequenceClip(fileList, fps=self.fps, with_mask = False, load_images = False)
# Write the mp4 file
"""
if os.path.exists(tmp + '/' + 'temp.m4a'):
clip.write_videofile(ofnam, fps=self.fps, audio = tmp + '/' + 'temp.m4a', audio_fps = 48000, codec='libx264', threads=0, ffmpeg_params = ['-crf', str(crf), '-g', str(frameint), '-pix_fmt', 'yuv420p', '-profile' ,'baseline'])
else:
print('No audio stream found, writing without...')
clip.write_videofile(ofnam, fps=self.fps, audio_fps = 48000, codec='libx264', threads=0, ffmpeg_params = ['-crf', str(crf), '-g', str(frameint), '-pix_fmt', 'yuv420p', '-profile' ,'baseline'])
"""
sys.stdout.flush()
clip = None
# Destroy the temporary directory
shutil.rmtree(tmp)
if self.copy_tmp is not None:
shutil.rmtree(self.copy_tmp)
def detectAndTrackLargestFace():
#Open the ip ptz camera
#capture = cv2.VideoCapture('rtsp://admin:@192.168.1.110:554/1/h264major latency=0')
capture = cv2.VideoCapture('rtsp://192.168.1.110:554/1/h264major')
#if need to use web-cam use the 0 option
#capture = cv2.VideoCapture(0)
#Create two opencv named windows
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
cv2.moveWindow("base-image",0,100)
cv2.moveWindow("result-image",400,100)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#Create the tracker we will use
tracker = dlib.correlation_tracker()
#The variable we use to keep track of the fact whether we are
#currently using the dlib tracker
trackingFace = 0
#The color of the rectangle we draw around the tracking object face or upper body
rectangleColor = (78,0,137)
try:
current_x = 0
count = 2
focused = True
center_coords = 180
max_error = 0
h_error = 0
custom_tracker = False
no_rot_in_progress = False
custom_sync = True
start_timer = None
custom_sync_main = True
custom_sync_vertical = True
start_timer_v = None
time_required = 0
start_tl = None
check_vertical = False
time_required_v = 0
while True:
#Retrieve the latest image from the ip-cam / webcam
rc,fullSizeBaseImage = capture.read()
#Resize the image to 320x240
baseImage = cv2.resize( fullSizeBaseImage, ( 320, 240))
#Check if a key was pressed and if it was Q, then destroy all
#opencv windows and exit the application
pressedKey = cv2.waitKey(2)
if pressedKey == ord('Q'):
cv2.destroyAllWindows()
exit(0)
#Result image is the image we will show the user, which is a
#combination of the original image from the ip-cam / webcam and the
#overlayed rectangle for the largest face
resultImage = baseImage.copy()
#If we are not tracking a face, then try to detect one
if not trackingFace:
#For the face detection, we need to make use of a gray
#colored image so we will convert the baseImage to a
#gray-based image
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
#Now use the haar cascade detector to find all faces
#in the image
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
#print("Using the cascade detector to detect face")
#we are only interested in the 'largest'
#face in order to detect lecturer, and we determine
#this based on the largest
#area of the found rectangle. First initialize the
#required variables to 0
maxArea = 0
x = 0
y = 0
w = 0
h = 0
#Loop over all faces and check if the area for this
#face is the largest so far
#We need to convert it to int here because of the
#requirement of the dlib tracker. If we omit the cast to
#int here, you will get cast errors since the detector
#returns numpy.int32 and the tracker requires an int
for (_x,_y,_w,_h) in faces:
if _w*_h > maxArea:
x = int(_x)
y = int(_y)
w = int(_w)
h = int(_h)
maxArea = w*h
#If one or more faces are found, initialize the tracker
#on the largest face in the picture
if maxArea > 0 :
#Initialize the tracker
tracker.start_track(baseImage,
dlib.rectangle( x-10,
y-20,
x+w+10,
y+h+20))
#Set the indicator variable such that we know the
#tracker is tracking a region in the image
trackingFace = 1
#Check if the tracker is actively tracking a region in the image
if trackingFace:
#Update the tracker and request information about the
#quality of the tracking update
trackingQuality = tracker.update( baseImage )
#If the tracking quality is good enough, determine the
#updated position of the tracked region and draw the
#rectangle
if trackingQuality >= 8.75:
#print("Detected Face")
start_tl = None
tracked_position = tracker.get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
cv2.rectangle(resultImage, (t_x, t_y),
(t_x + t_w , t_y + t_h),
rectangleColor ,2)
# if count>1:
# current_x = t_x
# count-=1
#print("Coordinates : " + str(t_x) + ", "+ str(t_y) + ", "+ str(t_h) + ", "+ str(t_w))
#print("rec : " + str(t_x) + ", "+ str(t_y) + ", "+ str(t_x + t_w) + ", "+ str(t_y + t_h))
#print("Center Coordinates : " + str(t_w/2) + ", "+ str(t_h/2))
#max_error = 5
# vm_cd = int(t_x)
# if current_x<180 and focused:
# rot_cen = (180-current_x)*22
# print('rotation time required ' + str(rot_cen))
# turn_left_ptz = execute_js('onvif_movement/turn_left.js',str(rot_cen))
# if turn_left_ptz:
# print('Focused Success - Turned Left')
# focused = False
# custom_tracker = True
# no_rot_in_progress = True
# else:
# print('failed left')
# if current_x>180 and focused:
# rot_cen = (current_x-180)*22
# print('rotation time required ' + str(rot_cen))
# turn_right_ptz = execute_js('onvif_movement/turn_right.js ',str(rot_cen))
# if turn_right_ptz:
# print('Focused Success - Turned Right')
# focused = False
# custom_tracker = True
# no_rot_in_progress = True
# else:
# print('failed right')
custom_tracker = True #True
no_rot_in_progress = True
current_pos = t_x
h_error = abs(180 - current_pos)
#print('h_error ' + str(h_error))
if custom_tracker and h_error > 40:
print('Distance found! ' + str(h_error))
check_vertical = False
if custom_sync_main:
print('Tracker Standby')
if current_pos < 140:
no_rot_in_progress = False
#rot_cen = (180 - current_pos) * 22
rot_cen = abs((130 - t_x) * 11)
print('Rotation Time Required ' + str(rot_cen))
if start_timer is None:
start_timer = timer()
turn_left_ptz = muterun_js('onvif_movement/turn_left.js', str(rot_cen))
custom_sync = True
rot_cen_in_sec = int(rot_cen / 1000)
time_required = rot_cen_in_sec + 2
end_timer = timer()
timer_diff = int(end_timer - start_timer)
if timer_diff >= time_required:
custom_sync = True
else:
custom_sync = False
if custom_sync:
start_timer = None
custom_sync_main = True
else:
custom_sync_main = False
if turn_left_ptz.exitcode == 0:
print('Custom Tracker - Turned Left')
no_rot_in_progress = True
#print(response.stdout)
else:
print('failed left')
#sys.stderr.write(response.stderr)
if current_pos > 220:
no_rot_in_progress = False
#rot_cen = (180 - current_pos) * 22
rot_cen = abs((130 - t_x) * 11)
print('Rotation Time Required ' + str(rot_cen))
if start_timer is None:
start_timer = timer()
turn_left_ptz = muterun_js('onvif_movement/turn_right.js', str(rot_cen))
custom_sync = True
rot_cen_in_sec = int(rot_cen / 1000)
time_required = rot_cen_in_sec + 2
end_timer = timer()
timer_diff = int(end_timer - start_timer)
if timer_diff >= time_required:
custom_sync = True
else:
custom_sync = False
if custom_sync:
start_timer = None
custom_sync_main = True
else:
custom_sync_main = False
if turn_left_ptz.exitcode == 0:
print('Custom Tracker - Turned Right')
no_rot_in_progress = True
# print(response.stdout)
else:
print('failed right')
else:
print('Tracker Waiting!')
#custom_tracker = False
end_timer = timer()
timer_diff = int(end_timer - start_timer)
if timer_diff >= time_required:
custom_sync = True
else:
custom_sync = False
if custom_sync:
start_timer = None
custom_sync_main = True
else:
custom_sync_main = False
else:
print('Lecturer Horizontal Distance Under Control! ' + str(h_error))
check_vertical = True
# vertical tracker controller
current_pos_vertical = t_y
v_error = abs(63 - current_pos_vertical)
if check_vertical and custom_sync_vertical and v_error > 22:
print('Vertical Distance Found! ' + str(v_error))
rot_cen_vertical = abs((63 - current_pos_vertical) * 12)
print('Vertical Rotation Time Required ' + str(rot_cen_vertical))
if current_pos_vertical < 40:
#print('Need to move down - script up')
if start_timer_v is None:
start_timer_v = timer()
turn_down_ptz = muterun_js('onvif_movement/turn_up.js', str(rot_cen_vertical))
rot_cen_v_in_sec = int(rot_cen_vertical / 1000)
time_required_v = rot_cen_v_in_sec + 2
end_timer_v = timer()
timer_diff_v = int(end_timer_v - start_timer_v)
if timer_diff_v >= time_required_v:
start_timer_v = None
custom_sync_vertical = True
else:
custom_sync_vertical = False
if turn_down_ptz.exitcode == 0:
print('Vertical Tracker - Turned Down')
else:
print('failed down')
if current_pos_vertical > 85:
#print('Need to move up script down')
if start_timer_v is None:
start_timer_v = timer()
turn_down_ptz = muterun_js('onvif_movement/turn_down.js', str(rot_cen_vertical))
rot_cen_v_in_sec = int(rot_cen_vertical / 1000)
time_required_v = rot_cen_v_in_sec + 2
end_timer_v = timer()
timer_diff_v = int(end_timer_v - start_timer_v)
if timer_diff_v >= time_required_v:
start_timer_v = None
custom_sync_vertical = True
else:
custom_sync_vertical = False
if turn_down_ptz.exitcode == 0:
print('Vertical Tracker - Turned Up')
else:
print('failed up')
else:
print('Lecturer Vertical Distance Under Control! ' + str(v_error))
#print('check vert ' + str(check_vertical))
#print('check custom_sync_main ' + str(custom_sync_main))
#print('check custom_sync_vertical ' + str(custom_sync_vertical))
#if check_vertical and custom_sync_main and not custom_sync_vertical:
if check_vertical and not custom_sync_vertical:
print('unlocked vertical locked within')
# custom_sync_vertical = True
end_timer_v = timer()
timer_diff_v = int(end_timer_v - start_timer_v)
if timer_diff_v >= time_required_v:
start_timer_v = None
custom_sync_vertical = True
else:
custom_sync_vertical = False
#print (custom_sync_vertical)
# print('v_error ' + str(current_pos_vertical))
# end of vertical tracker
else:
#If the quality of the tracking update is not
#sufficient (e.g. the tracked region moved out of the
#screen) we stop the tracking of the face and in the
#next loop we will find the largest face in the image
#again
trackingFace = 0
print("Tracking Lost")
else:
if start_tl is None:
start_tl = time.time()
end_tl = time.time()
diff_tl = abs(end_tl - start_tl)
# wait for 10 seconds
if diff_tl >= 10:
print('Camera will be Recalibrated!')
recalibrate_ptz = execute_js('onvif_movement/recal_lost_lec.js')
if recalibrate_ptz:
print('Recalibrate Success')
start_tl = None
else:
print('Recalibrate Failure')
else:
print('Waiting for Lecturer!')
#Since we want to show something larger on the screen than the
#original 320x240, we resize the image again
#
#Note that it would also be possible to keep the large version
#of the base-image and make the result image a copy of this large
#base image and use the scaling factor to draw the rectangle
#at the right coordinates.
largeResult = cv2.resize(resultImage,
(OUTPUT_SIZE_WIDTH,OUTPUT_SIZE_HEIGHT))
#Finally, we want to show the images on the screen
cv2.imshow("base-image", baseImage)
cv2.imshow("result-image", largeResult)
#To ensure we can also deal with the user pressing Ctrl-C in the console
#we have to check for the KeyboardInterrupt exception and destroy
#all opencv windows and exit the application
except KeyboardInterrupt as e:
#turn_recal_ptz = execute_js('onvif_movement/recalibrate.js')
cv2.destroyAllWindows()
exit(0)
def retrieve_corners_from_image(frame: np.ndarray, ):
"""
Opens a window and waits for the user to click on all corners of the polygonal arena.
The user should click on the corners in sequential order.
Args:
frame (np.ndarray): Frame to display.
Returns:
corners (np.ndarray): nx2 array containing the x-y coordinates of all n corners.
"""
corners = []
def click_on_corners(event, x, y, flags, param):
# Callback function to store the coordinates of the clicked points
nonlocal corners, frame
if event == cv2.EVENT_LBUTTONDOWN:
corners.append((x, y))
# Create a window and display the image
cv2.startWindowThread()
while True:
frame_copy = frame.copy()
cv2.imshow(
"deepof - Select polygonal arena corners - (q: exit / d: delete)",
frame_copy,
)
cv2.setMouseCallback(
"deepof - Select polygonal arena corners - (q: exit / d: delete)",
click_on_corners,
)
# Display already selected corners
if len(corners) > 0:
for c, corner in enumerate(corners):
cv2.circle(frame_copy, (corner[0], corner[1]), 4,
(40, 86, 236), -1)
# Display lines between the corners
if len(corners) > 1 and c > 0:
cv2.line(
frame_copy,
(corners[c - 1][0], corners[c - 1][1]),
(corners[c][0], corners[c][1]),
(40, 86, 236),
2,
)
# Close the polygon
if len(corners) > 2:
cv2.line(
frame_copy,
(corners[0][0], corners[0][1]),
(corners[-1][0], corners[-1][1]),
(40, 86, 236),
2,
)
cv2.imshow(
"deepof - Select polygonal arena corners - (q: exit / d: delete)",
frame_copy,
)
# Remove last added coordinate if user presses 'd'
if cv2.waitKey(1) & 0xFF == ord("d"):
corners = corners[:-1]
# Exit is user presses q
elif cv2.waitKey(1) & 0xFF == ord("q"):
cv2.destroyAllWindows()
cv2.waitKey(1)
break
cv2.destroyAllWindows()
cv2.waitKey(1)
# Return the corners
return corners
def detectAndTrackLargestFace():
#Open the first webcame device
capture = cv2.VideoCapture(0)
#Create two opencv named windows
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("mosaic-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
cv2.moveWindow("base-image", 0, 0)
cv2.moveWindow("result-image", 400, 0)
cv2.moveWindow("mosaic-image", 0, 400)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#Create the tracker we will use
tracker = dlib.correlation_tracker()
#The variable we use to keep track of the fact whether we are
#currently using the dlib tracker
trackingFace = 0
#The color of the rectangle we draw around the face
rectangleColor = (0, 165, 255)
try:
while True:
#Retrieve the latest image from the webcam
rc, fullSizeBaseImage = capture.read()
#Resize the image to 320x240
baseImage = cv2.resize(fullSizeBaseImage, (320, 240))
#Check if a key was pressed and if it was Q, then destroy all
#opencv windows and exit the application
if cv2.waitKey(1) & 0xFF == ord('Q'):
quit()
#Result image is the image we will show the user, which is a
#combination of the original image from the webcam and the
#overlayed rectangle for the largest face
resultImage = baseImage.copy()
mosaicImage = baseImage.copy()
#If we are not tracking a face, then try to detect one
if not trackingFace:
#For the face detection, we need to make use of a gray
#colored image so we will convert the baseImage to a
#gray-based image
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
#Now use the haar cascade detector to find all faces
#in the image
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
#In the console we can show that only now we are
#using the detector for a face
print("Using the cascade detector to detect face")
#For now, we are only interested in the 'largest'
#face, and we determine this based on the largest
#area of the found rectangle. First initialize the
#required variables to 0
maxArea = 0
x = 0
y = 0
w = 0
h = 0
#Loop over all faces and check if the area for this
#face is the largest so far
#We need to convert it to int here because of the
#requirement of the dlib tracker. If we omit the cast to
#int here, you will get cast errors since the detector
#returns numpy.int32 and the tracker requires an int
for (_x, _y, _w, _h) in faces:
if _w * _h > maxArea:
x = int(_x)
y = int(_y)
w = int(_w)
h = int(_h)
maxArea = w * h
#If one or more faces are found, initialize the tracker
#on the largest face in the picture
if maxArea > 0:
#Initialize the tracker
tracker.start_track(
baseImage,
dlib.rectangle(x - 10, y - 20, x + w + 10, y + h + 20))
#Set the indicator variable such that we know the
#tracker is tracking a region in the image
trackingFace = 1
#Check if the tracker is actively tracking a region in the image
if trackingFace:
#Update the tracker and request information about the
#quality of the tracking update
trackingQuality = tracker.update(baseImage)
#If the tracking quality is good enough, determine the
#updated position of the tracked region and draw the
#rectangle
if trackingQuality >= 5.5:
tracked_position = tracker.get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
# print("tracked", t_x, t_y, t_w, t_h)
cv2.rectangle(resultImage, (t_x, t_y),
(t_x + t_w, t_y + t_h), rectangleColor, 2)
m_x = int(t_x > 0 and t_x or 0)
m_y = int(t_y > 0 and t_y or 0)
m_w = int(t_x + t_w < 320 and t_w or 320 - t_x)
m_h = int(t_y + t_h < 240 and t_h or 240 - t_y)
print("MOSAIC", m_x, m_y, m_w, m_h)
# print(int(m_w) * int(m_h))
face_img = mosaicImage[m_y:m_y + m_h, m_x:m_x + m_w]
face_img = cv2.resize(
face_img, (m_w // MOSAIC_RATE, m_h // MOSAIC_RATE))
face_img = cv2.resize(face_img, (m_w, m_h),
interpolation=cv2.INTER_AREA)
mosaicImage[m_y:m_y + m_h, m_x:m_x + m_w] = face_img
else:
#If the quality of the tracking update is not
#sufficient (e.g. the tracked region moved out of the
#screen) we stop the tracking of the face and in the
#next loop we will find the largest face in the image
#again
trackingFace = 0
#Since we want to show something larger on the screen than the
#original 320x240, we resize the image again
#
#Note that it would also be possible to keep the large version
#of the baseimage and make the result image a copy of this large
#base image and use the scaling factor to draw the rectangle
#at the right coordinates.
largeResult = cv2.resize(resultImage,
(OUTPUT_SIZE_WIDTH, OUTPUT_SIZE_HEIGHT))
mosaicResult = cv2.resize(mosaicImage,
(OUTPUT_SIZE_WIDTH, OUTPUT_SIZE_HEIGHT))
#Finally, we want to show the images on the screen
cv2.imshow("base-image", baseImage)
cv2.imshow("result-image", largeResult)
cv2.imshow("mosaic-image", mosaicResult)
#To ensure we can also deal with the user pressing Ctrl-C in the console
#we have to check for the KeyboardInterrupt exception and destroy
#all opencv windows and exit the application
except KeyboardInterrupt as e:
cv2.destroyAllWindows()
exit(0)
