def main(): print "\t\t########################################" print "\t\tOPTIMISED = ",cv2.useOptimized()," !!!!" print "\t\t########################################" while True: ret,img=cap.read() #img = cv2.medianBlur(img,3) # 5 is a fairly small kernel size img = cv2.resize(img,None,fx=1.3,fy=1,interpolation = cv2.INTER_LINEAR) hand_box = [(0,50),(400,400)] head_box = [(500,50),(800,400)] cv2.rectangle(img,hand_box[0],hand_box[1],(255,255,255),2) cv2.rectangle(img,head_box[0],head_box[1],(50,50,50),2) head_frame = img[50:400,500:800] try: img[50:400,500:800] = lipSegment(head_frame) except ValueError, e: #print e pass hand_frame = img[50:400,0:400] try: mask,counter,hull,(cx,cy),list_far,list_end = count_fingers(hand_frame) if(cv2.contourArea(hull)>3000) and list_far: cv2.drawContours(hand_frame,[hull],0,(0,255,0),1) [cv2.circle(hand_frame,far,5,[0,0,0],-1) for far in list_far] [cv2.circle(hand_frame,end,5,[150,150,150],-1) for end in list_end] cv2.putText(hand_frame,"Fingers = "+str(counter+1),(10,250),cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255),2,1) except ZeroDivisionError, e: print "Count_fingers ZeroDivisionError: ",e
def image_callback(self, msg):
image = self.bridge.compressed_imgmsg_to_cv2(msg, desired_encoding='bgr8')
imageGray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.useOptimized()
cv2.setUseOptimized(True)
kp1, des1 = self.sift.detectAndCompute(self.blocking_img, None)
kp2, des2 = self.sift.detectAndCompute(imageGray, None)
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
try:
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
except Exception as ex:
print('knnMatch error')
return
good = []
for m, n in matches:
if m.distance < 0.7 * n.distance:
good.append(m)
outer_dst_pts = np.float32([])
if len(good) > MIN_MATCH_COUNT:
src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
outer_dst_pts = dst_pts
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
matchesMask = mask.ravel().tolist()
h, w, d= self.blocking_img.shape
pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2)
# dst = None
try:
dst = cv2.perspectiveTransform(pts, M)
except Exception as ex:
print('perspectiveTransform error: dst = %s' % dst)
return
image = cv2.polylines(image, [np.int32(dst)], True, (255, 0, 0), 3, cv2.LINE_AA)
self.match = True
rospy.logdebug('주차 표지판 탐지 : %s' % self.match)
else:
self.match = False
rospy.logdebug("Not enough matches are found - {}/{}".format(len(good), MIN_MATCH_COUNT))
matchesMask = None
#draw_params = dict(matchColor=(0, 255, 0),
# singlePointColor=None,
# matchesMask=matchesMask,
# flags=2)
# matches_img = cv2.drawMatches(self.blocking_img, kp1, image, kp2, good, None, **draw_params)
if show_matched_points:
for pt in outer_dst_pts:
x,y = pt[0]
cv2.circle(image, (x, y),3, (0,0,255), -1)
self.match_pub.publish(self.match)
#cv2.imshow('match', matches_img)
cv2.imshow("image", image)
cv2.waitKey(3)
import cv2 as cv import numpy as np import time print(cv.useOptimized()) # True,默认开启 ts1 = time.time() img1 = cv.imread(r'/home/qiao/PythonProjects/Opencv_On_CT/Test_Img/9.jpg') res1 = cv.medianBlur(img1, 49) te1 = time.time() print(te1 - ts1) cv.setUseOptimized(False) print(cv.useOptimized()) ts2 = time.time() img2 = cv.imread(r'/home/qiao/PythonProjects/Opencv_On_CT/Test_Img/9.jpg') res2 = cv.medianBlur(img2, 49) te2 = time.time() print(te2 - ts2) # True # 0.014556407928466797 # False # 0.014634370803833008 # 我这儿性能没提升呢？
# -*- coding: utf-8 -*- # __author__ = 'corvin' import cv2 import numpy as np ''' OpenCV 中的默认优化 在编译时 优化是 默认开启的。因此 OpenCV 的就是优化后的代码 如果你把优化 关闭的 就只能执行低效的代码了。 你可以使用函数 cv2.useOptimized() 来查看优化是否 开启了 使用函数 cv2.setUseOptimized() 来开启优化 ''' # check if optimization is enabled """ In [5]: cv2.useOptimized() Out[5]: True In [6]: %timeit res = cv2.medianBlur(img,49) 10 loops, best of 3: 34.9 ms per loop # Disable it In [7]: cv2.setUseOptimized(False) In [8]: cv2.useOptimized() Out[8]: False In [9]: %timeit res = cv2.medianBlur(img,49) #优化后中值滤波的速度是原来的两倍 """ print(cv2.useOptimized()) cv2.setUseOptimized(False) print(cv2.useOptimized())
当数组的大小是 2 的指数时 DFT 效率最高。
当数组的大小是 2，3，5 的倍数时效率也会很高。所以如果你想提高代码的运行效率时，你可以修改输入图像的大小（补 0）。
对于OpenCV 你必须自己手动补 0。但是 Numpy，你只需要指定 FFT 运算的大小，它会自动补 0。
最佳大小:OpenCV 提供了一个函数:cv2.getOptimalDFTSize()。
OpenCV 的速度是 Numpy 的 3 倍。
"""
import cv2
import numpy as np
import time
img = cv2.imread('./image/girl001.jpg', 0)
rows, cols = img.shape
print(rows, cols)
nrows = cv2.getOptimalDFTSize(rows)
ncols = cv2.getOptimalDFTSize(cols)
print(nrows, ncols)
nimg = np.zeros((nrows, ncols))
nimg[:rows, :cols] = img
if cv2.useOptimized():
fft1 = np.fft.fft2(img)
fft2 = np.fft.fft2(img, [nrows, ncols])
dft1 = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
dft2 = cv2.dft(np.float32(nimg), flags=cv2.DFT_COMPLEX_OUTPUT)
def closing(img):
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel, iterations=2)
return img
img = cv2.imread('F:\\Documents\\IMGW\\HomeWork1\\R6.jpg',0)
cv2.imshow('origin', img)
#Binarization
img[img > 128] = 255
img[img <= 128] = 0
cv2.imwrite('F:\\Documents\\IMGW\\HomeWork1\\GRAY.jpg',img)
cv2.setUseOptimized(True)
print('----------opening x100----------','\n')
print ('Enable AVX:',cv2.useOptimized())
opening_with_avx = img
start = timeit.default_timer()
for i in range (0,100):
opening_with_avx = opening(opening_with_avx)
stop = timeit.default_timer()
t1 = stop - start
print('Runtime with AVX: ', t1,"\n")
opening_without_avx = img
cv2.setUseOptimized(False)
print ('Enable AVX:',cv2.useOptimized())
start = timeit.default_timer()
def run(self):
#Video goes here. New videos / camera setup need new parametrization:
print(cv2.useOptimized())
if self.inputType == 'FILE':
cap = cv2.VideoCapture(self.input)
else:
cap = cv2.VideoCapture(0)
cap.set(3,480)
cap.set(4,360)
cap.set(5,5)
#camera = PiCamera()
#camera.resolution = (480, 360)
#camera.framerate = 5
#rawCapture = PiRGBArray(camera, size=(480, 360))
## allow the camera to warmup
#time.sleep(0.1)
#Counter for all passed objects
runningID = 0
#Array of objects currently tracked
trackedObjects = []
#Objects not detected anymore in current frame
toDelete = []
#Labeling font
font = cv2.FONT_HERSHEY_SIMPLEX
#framecounter to skip n frames and improve performance
framecount = 0
#Counters for passed obejcts
countIn = 2
countOut = 0
self.Running = True
#do until user interruption
while(self.Running == True):
framecount=framecount + 1
ret, frame = cap.read()
#grab next frame and increase framecounter
#change the modulo to skip frames. currently consider each frame
if (framecount % self.frameRatio) == 0:
#for capture in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
#frame = capture.array
#coose region of interest and apply foreground subtractor to it
fgmask = self.fgbg.apply(frame)
#Smooth the detected foreground
blurred = cv2.medianBlur(fgmask,self.blurRadius)
#Find countours around detected objects
cv2.imshow('frame1', blurred)
image, contours, hierarchy = cv2.findContours(blurred,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#print('\n')
#Loop through all detected objects in current frame
a = int(round(time.time() * 1000))
for cnt in contours:
#Get the moments (information about object density or so)
M = cv2.moments(cnt)
#Make sure we can divide by zero-moment and the object has a certain size.
#Size threshold to be found empirically
if (M['m00'] > 0 and cv2.contourArea(cnt) > self.areaThreshold):
#Calculate centroid
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
#Store area
area = cv2.contourArea(cnt)
print('Area: ')
print(area)
#Redundant area check...first could be removed I guess
#Object of interest. We assume it is not tracked yet
tracked = False
#Loop through all tracked objects and calculate the distance of the centroid to the current object
for i in range(len(trackedObjects)):
#distance calculation...pythagoras
distance = math.sqrt((cx-trackedObjects[i][1])*(cx-trackedObjects[i][1])+(cy-trackedObjects[i][2])*(cy-trackedObjects[i][2]))
#print for debug
print('Distance; ')
print(distance)
#If the distance to a certain tracked object is smaller than a certain threshold, we
#assume it is the same object and distance is due to movement. More sophisticated criteria could be included here
#such as shape info etc.
if(distance < self.speedLimit):
#check whether the objects has passed an imaginary counting line in either direction since the last frame
if(cy < self.barrier and trackedObjects[i][2] > self.barrier):
countIn+=1
self.occupancy += 1
elif(cy > self.barrier and trackedObjects[i][2] < self.barrier):
countOut +=1
self.occupancy -=1
#Update information of the tracked object, since it is the same
trackedObjects[i][1] = cx
trackedObjects[i][2] = cy
trackedObjects[i][3] = area
#This is used to sort out the objects later that disappeared in the current frame
trackedObjects[i][4] = True
if(self.display==True):
#Draw a contour around it
frame = cv2.drawContours(frame, [cnt], 0, (255,0,0), 3)
cv2.putText(frame,str(trackedObjects[i][0]),(cx,cy), font, 2,(255,0,0),2,cv2.LINE_AA)
#Mark the object as tracked.
tracked = True
#Break loop. One object can not be tracked multiple times :)
break
#If the object is identified as new object
if tracked == False:
#assign new ID
runningID = runningID + 1
#Store its ID, centroid, area and track status in the array of tracked objects
trackedObjects.append([runningID,cx,cy,area,True])
if(self.display==True):
#Draw the bounding box
frame = cv2.drawContours(frame, [cnt], 0, (255,0,0), 3)
#Label it
cv2.putText(frame,str(runningID),(int(cx),int(cy)), font, 2,(255,0,0),2,cv2.LINE_AA)
#Loop through all tracked objects and verify whether they still exist in the current frame
for i in range(len(trackedObjects)):
if(trackedObjects[i][4]) == False:
toDelete.append(trackedObjects[i])
else:
trackedObjects[i][4] = False
#Delete objects which left the frame
for i in range(len(toDelete)):
trackedObjects.remove(toDelete[i])
#Empty storage for objects to delete
toDelete = []
if(self.display==True):
#Draw counting line
cv2.line(frame,(0,self.barrier),(480,self.barrier),(0,255,0),3)
#Display passed objects in either direction
cv2.putText(frame,"In"+str(countIn),(20,180), font, 1,(0,255,0),1,cv2.LINE_AA)
cv2.putText(frame,"Out"+str(countOut),(160,180), font, 1,(0,255,0),1,cv2.LINE_AA)
#Finally, display the current frame with the tracked objects and counters
cv2.imshow('frame', frame)
cv2.waitKey(250)
#rawCapture.truncate(0)
b = int(round(time.time() * 1000))
print("Frametime: ")
c=b-a
print(c)
import cv2
from time import sleep
print("optimized cv="+str(cv2.useOptimized()))
def printTimeSinceLastMeasurement(name):
global start_time
print(name+" took "+str((cv2.getTickCount() - start_time)/cv2.getTickFrequency()))
start_time=cv2.getTickCount()
### start init code
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("No capture device")
sys.exit()
# resolution xy
print(str(cap.get(3))+"x"+str(cap.get(4)))
ret = cap.set(3,320)
ret = cap.set(4,240)
print(" now set to "+str(cap.get(3))+"x"+str(cap.get(4)))
# framerate (will stay at 30)
ret = cap.set(5,60)
print(str(cap.get(5))+" fps")
#read one frame to init
_, img = cap.read()
### end Init code
start_time = cv2.getTickCount()
### ##
count=0
# extract main background and logo foreground
im_fg = cv2.bitwise_and(im_roi, im_roi, mask=im_mask)
im_bg = cv2.bitwise_and(im_2, im_2, mask=im_imask)
# add the logo to the main image
im_edit = cv2.add(im_bg, im_fg)
im_1[0:rows, 0:cols] = im_edit
cv2.imshow('overlayed', im_1)
#------------------------------------------------------------
# How To Instrument Code
#------------------------------------------------------------
# One can also use the %timeit command in ipython
#------------------------------------------------------------
if not cv2.useOptimized(): # should be on by default
cv2.setUseOptimized(True)
t1 = cv2.getTickCount()
# ... your code execution ...
t2 = cv2.getTickCount()
time = (t2 - t1) / cv2.getTickFrequency()
#------------------------------------------------------------
# Color Conversion
#------------------------------------------------------------
im_gray = cv2.cvtColor(im_1, cv2.COLOR_BGR2GRAY)
im_hsv = cv2.cvtColor(im_1, cv2.COLOR_BGR2HSV)
def main():
print(cv2.useOptimized())
data_left = np.load('Left_calibrated.npy').item()
data_right = np.load('Right_calibrated.npy').item()
data = np.load('intrs.npy').item()
objp_left, objp_right, imgp_left, imgp_right = data['OBJL'], data[
'OBJR'], data['IMPL'], data['IMGR']
KL, DL, DIML = data_left['K'], data_left['D'], data_left['DIM']
KR, DR, DIMR = data_right['K'], data_right['D'], data_right['DIM']
KL = np.array(KL)
DL = np.array(DL)
KR = np.array(KR)
DR = np.array(DR)
flags = 0
# flags |= cv2.CALIB_ZERO_TANGENT_DIST
flags |= cv2.fisheye.CALIB_FIX_SKEW
# flags |= cv2.CALIB_ZERO_TANGENT_DIST
flags |= cv2.fisheye.CALIB_CHECK_COND
flags |= cv2.fisheye.CALIB_RECOMPUTE_EXTRINSIC
flags |= cv2.fisheye.CALIB_FIX_K4
termination_criteria_extrinsics = (cv2.TERM_CRITERIA_EPS +
cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
(rms_stereo, _, _, _, _, R, T, E, F) = \
cv2.stereoCalibrate(objp_right, imgp_left, imgp_right, KL, DL, KR, DR, DIML,
criteria=termination_criteria_extrinsics, flags = flags)
print(rms_stereo)
camL = cv2.VideoCapture(0)
camR = cv2.VideoCapture(1)
RGB_false(camL)
RGB_false(camR)
make_480p(camL)
make_480p(camR)
while camL.grab() and camR.grab():
e1 = cv2.getTickCount()
_, frameL = camL.retrieve()
_, frameR = camR.retrieve()
#print(frameR.shape)
left_calibrated = undistorted(f8(frameL), data_left)
right_calibrated = undistorted(f8(frameR), data_right)
#fps = camL.get(cv2.CAP_PROP_FPS)
#print("Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}".format(fps))
stackedFrames = np.concatenate((left_calibrated, right_calibrated),
axis=1)
cv2.imshow("calibrated", stackedFrames)
#cv2.imshow("calibrated", left_calibrated)
key = cv2.waitKey(40) & 0xFF
if key == ord('q'):
break
elif key == ord('s'):
tmp = camL
camL = camR
camR = tmp
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print(t)
camL.release()
cv2.destroyAllWindows()
def appStarted(app):
initConstants(app)
app.running = False
app.count = 0
cv2.setUseOptimized(True)
print(cv2.useOptimized())
import numpy as np
import cv2
cv2.setUseOptimized(True)
print('Optimized status:', cv2.useOptimized())
img = cv2.imread('omj.jpg')
e1 = cv2.getTickCount()
rng = range(5, 49, 2)
for i in rng:
img = cv2.medianBlur(img, i)
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print('Elapsed time:', t, 's')
'''
cv2.useOptimized()
cv2.setUseOptimized(False)
'''
'''
cv2.imshow("figure", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''
# author: roczhang
# file: demo_3.py
# time: 2021/05/14
from timeit import timeit
import cv2 as cv
import numpy as np
img1 = cv.imread('/data/file/img/data/messi5.jpg')
e1 = cv.getTickCount()
for i in range(5, 49, 2):
img1 = cv.medianBlur(img1, i)
e2 = cv.getTickCount()
t = (e1 - e2) / cv.getTickFrequency()
print(t)
cv.useOptimized()
if __name__ == "__main__":
args = get_args()
coco_writer = None
in_annots = None
e_video_exts = ['webm']
video_exts = ['mp4', 'avi']
image_exts = ['jpg', 'png']
e_kwargs = [dict() for _ in range(len(args.e_paths))]
if args.kwargs:
keys = args.kwargs[0]
for i, values in enumerate(args.kwargs[1:len(e_kwargs) + 1]):
e_kwargs[i] = {k: v for k, v in zip(keys, values)}
print('OpenCV is optimized:', cv2.useOptimized())
if args.skip_annotations:
print('Not writing annotaions!')
if args.in_annotations is not None:
in_annots = COCO(args.in_annotations)
print('Building path to img id mapping...')
path2img_id = dict()
for img in in_annots.imgs.values():
path2img_id[img['file_name']] = img['id']
in_annots.__dict__['root_path'] = args.in_path
in_annots.__dict__['path2img_id'] = path2img_id
# Get path for effects
e_readers, e_cfgs = [], []
for i, (path, kwargs) in enumerate(zip(args.e_paths, e_kwargs)):
out[0:h, 0:w] = frame
writer.write(out)
cv2.imshow("Output", out)
cv2.resize(out, (400, 400))
if cv2.waitKey(1) & 0xFF == ord("q"):
print()
print("[WARNING] pressed q button...")
print()
break
print("[INFO] cleaning up ....")
print()
cv2.destroyAllWindows()
writer.release()
vid.release()
if __name__ == "__main__":
print("[INFO] checking for linux OS platform ...")
print()
if platform.lower() in {"linux", "linux2"}:
if not cv2.useOptimized():
cv2.setUseOptimized(True)
main()
elif platform.lower() in {"darwin", "win32"}:
print("Not a linux platform ...")
exit()
###################################
##### Authors: #####
##### Stephane Vujasinovic #####
##### Frederic Uhrweiller #####
##### #####
##### Creation: 2017 #####
###################################
import numpy as np
import cv2
import time
cv2.useOptimized()
print(
'Starting the Calibration just press the space bar to exit this part of the Programm\n'
)
print(
'Push (s) to save the image you want and push (c) to see next frame without saving the image'
)
# Contador de Imagenes guardadas
i = 0
# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
# Prepare object points
objp = np.zeros((9 * 6, 3), np.float32)
objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)
# Arrays to store object points and image points from all images
from objectDetector import ObjectDetector
from stream import Stream
from fps import FPS
import cv2
# enable optimised mode if possible
optimized = cv2.useOptimized()
if not optimized:
cv2.setUseOptimized(True)
# initialise new frontal face detector
faceDetector = ObjectDetector(model='FRONTAL_FACE', minSize=35)
# start new video capture
capture = Stream(src=0).start()
# initialise an array to store detected objects
objects = []
# start FPS recorder
fps = FPS().start()
while True:
ret, frame = capture.read()
# optional resize to reduce computation
# frame = cv2.resize(frame, (0, 0), fx=0.35, fy=0.35)
# get new detected objects
objects = faceDetector.detect(frame)
from matplotlib import pyplot as plt
wincount = 0
def win(*img_list):
global wincount
for img in img_list:
cv2.imshow('win%d'%wincount,img)
wincount += 1
if __name__ =='__main__':
#------ Main ------
print('OpenCV is %soptimized'%('' if cv2.useOptimized() else 'not '))
img_name = r'color\colorruler.jpg'
img = cv2.imread(r'F:\Workplace\GroundStation\imageprocess\%s'%img_name,cv2.IMREAD_COLOR)
s = img.tostring()
newimg = np.ndarray(shape=img.shape, dtype=img.dtype,buffer = s)
cv2.imshow('',newimg)
cv2.waitKey(0)
# print(img) = [BGR(1,:);BGR(2,:);...;BGR(n,:)]
#------ matplotlib usage ------
# plt.imshow(img[:,:,::-1], cmap = 'gray', interpolation = 'bicubic')#BGR to RGB
# plt.show()
# -*- coding: utf-8 -*-
"""
Created on 2016年5月10日 上午11:41:01
@author: Thunderbolt.Lei （花名：穆雷）
@description: 此实例的图像混合，保持了原图的颜色，并根据像素的重新运算，实现图像的混合<br>
"""
import cv2
import numpy as np
# cv2.setUseOptimized(False)
# check if optimization is enabled, the default option is enabled
ret = cv2.useOptimized()
print ret
e1 = cv2.getTickCount()
# 加载图像
img1 = cv2.imread("../../../datas/imgs/Faces.jpg")
img2 = cv2.imread("../../../datas/imgs/bg01.png")
# I want to put logo on top-left corner, So I create a ROI
rows, cols, channels = img2.shape
roi = img1[0:rows, 0:cols]
# Now create a mask of logo and create its inverse mask also
img2gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(img2gray, 175, 255, cv2.THRESH_BINARY)
def __init__(self, height=320, width=240, template='Puck'):
self.template = cv2.imread('templates/' + template + '.png',0)
self.cap = cv2.VideoCapture(0)
cv2.useOptimized()
self.cap.set(3, height)
self.cap.set(4, width)
# 函数运行时间和性能优化（有问题）
import cv2 as cv
import time
cv.setUseOptimized(True)
img = cv.imread("C:\\Users\\Admin\\Desktop\\image\\airfield.bmp")
# e1 = cv.getTickCount() # 开始获取时钟周期数
e1 = time.time() # 法二：使用time模块
for i in range(5, 49, 2):
img = cv.medianBlur(img, i)
# e2 = cv.getTickCount() # 获取结束时钟周期数e
e2 = time.time()
# t = (e2-e1)/cv.getTickFrequency() # 获取时钟周期频率
t = e2 - e1
print(t)
print(cv.useOptimized())
if cv.useOptimized() == True:
cv.setUseOptimized(False)
print(cv.useOptimized())
e3 = time.time() # 法二：使用time模块
for i in range(5, 49, 2):
img = cv.medianBlur(img, i)
e4 = time.time()
t = e4 - e3
print(t)
# Take only region of logo from logo image.
img2_fg = cv2.bitwise_and(img2, img2, mask=mask)
# Put logo in ROI and modify the main image
dst = cv2.add(img1_bg, img2_fg)
img1[0:rows, 0:cols] = dst
cv2.imshow('bitwise', img1)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''
Default Optimization in OpenCV
https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_core/py_optimization/py_optimization.html
'''
cv2.useOptimized() # check if optimization is enabled
print(cv2.useOptimized())
res1 = cv2.medianBlur(img, 49)
# optimization is disabled
cv2.setUseOptimized(False)
cv2.useOptimized()
print(cv2.useOptimized())
res1 = cv2.medianBlur(img, 49)
cv2.imshow('res1', res1)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''
Measuring Performance with OpenCV
https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_core/py_optimization/py_optimization.html
'''
imgName = 'img.jpg'
dataFolder = '../DATA/'
img = cv2.imread(dataFolder + imgName, 1)
f = cv2.getTickFrequency(
) #Frequency of clock-cycles (clock-cycles-num/second)
enableOpt = raw_input('Use optimization (yes/no): ')
if (enableOpt == 'yes'):
cv2.setUseOptimized(True)
else:
cv2.setUseOptimized(False)
print "Optimization: " + str(cv2.useOptimized()) #Optimization setting
e1 = cv2.getTickCount() #Number of clock-cycles when execution started
t1 = time.time() #Time when execution started
#Functions - mesuring execution time
for i in xrange(5, 49, 2):
img1 = cv2.medianBlur(img, i)
print "NumZero: " + str(np.count_nonzero(img))
e2 = cv2.getTickCount() #Number of clock-cycles when execution ended
t2 = time.time() #Time when execution ended
time = (e2 - e1) / f #Time of execution in seconds
print "Time: (" + str(e2) + "-" + str(e1) + ")" + "/" + str(f) + " = " + str(
time)
import cv2
from threading import Thread
import numpy as np
from time import sleep
import enum
import time
import math
import threading
print(cv2.useOptimized(), "use optimized")
class targetRegion(enum.Enum):
topLeft = 0
top = 1
topRight = 2
right = 3
bottomRight = 4
bottom = 5
bottomLeft = 6
left = 7
center = 8
class tapePos:
def __init__(self, qu):
self.qu = qu
self.img = None
self.exposure = 157 #ms #ON CORAL
self.white_balance = 100 #CHANGE #ON CORAL
self.hue = (20, 255) #Pixel
def __init__(self, parent, fps=15, height=240,width=320):
wx.Frame.__init__(self, parent)
self.SetName("Mask Tester Controller")
#Boolean to handle exiting CV2 IMSHOW window
self.exists = True
#Colors for applying the mask
self.upper_color = self.color_RGB2HSV([0,0,0])
self.lower_color = self.color_RGB2HSV([0,0,0])
self.cap = cv2.VideoCapture(0)
cv2.useOptimized()
self.cap.set(3, height)
self.cap.set(4, width)
## GUI CODE BELOW ##
MainBox = wx.BoxSizer(wx.HORIZONTAL)
StaticBox1 = wx.StaticBox(self,label='Lower Color')
StaticBox2 = wx.StaticBox(self,label='Upper Color')
LowerBox = wx.StaticBoxSizer(StaticBox1, wx.VERTICAL)
LowerSizer = wx.FlexGridSizer(3,3,10,15)
UpperBox = wx.StaticBoxSizer(StaticBox2, wx.VERTICAL)
UpperSizer = wx.FlexGridSizer(3,3,10,15)
ComboBoxSizer = wx.FlexGridSizer(1,2,10,15)
self.ComboBoxText = wx.StaticText(self,id=1,label="Image from:\t")
self.Choices = ["Frame","HSV","Mask","Res"]
self.ComboBox = wx.ComboBox(self,value=self.Choices[0],choices=self.Choices,style=wx.CB_READONLY)
ComboBoxSizer.Add(self.ComboBoxText,flag=wx.ALIGN_CENTER)
ComboBoxSizer.Add(self.ComboBox,flag=wx.ALIGN_CENTER)
self.R_lowerTextLabel = wx.StaticText(self,id=1,label="R")
self.G_lowerTextLabel = wx.StaticText(self,id=2,label="G")
self.B_lowerTextLabel = wx.StaticText(self,id=3,label="B")
self.R_lower = wx.Slider(self,id=1,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.G_lower = wx.Slider(self,id=2,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.B_lower = wx.Slider(self,id=3,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.R_lowerText = wx.StaticText(self,id=1,label="0")
self.G_lowerText = wx.StaticText(self,id=2,label="0")
self.B_lowerText = wx.StaticText(self,id=3,label="0")
LowerSizer.Add(self.R_lowerTextLabel,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.R_lower,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.R_lowerText,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.G_lowerTextLabel,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.G_lower,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.G_lowerText,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.B_lowerTextLabel,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.B_lower,flag=wx.ALIGN_CENTER)
LowerSizer.Add(self.B_lowerText,flag=wx.ALIGN_CENTER)
self.R_upperTextLabel = wx.StaticText(self,id=1,label="R")
self.G_upperTextLabel = wx.StaticText(self,id=2,label="G")
self.B_upperTextLabel = wx.StaticText(self,id=3,label="B")
self.R_upper = wx.Slider(self,id=4,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.G_upper = wx.Slider(self,id=5,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.B_upper = wx.Slider(self,id=6,value=0,minValue=0,maxValue=255,size=(200,20),style=wx.SL_HORIZONTAL)
self.R_upperText = wx.StaticText(self,id=4,label="0")
self.G_upperText = wx.StaticText(self,id=5,label="0")
self.B_upperText = wx.StaticText(self,id=6,label="0")
UpperSizer.Add(self.R_upperTextLabel,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.R_upper,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.R_upperText,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.G_upperTextLabel,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.G_upper,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.G_upperText,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.B_upperTextLabel,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.B_upper,flag=wx.ALIGN_CENTER)
UpperSizer.Add(self.B_upperText,flag=wx.ALIGN_CENTER)
LowerBox.Add(LowerSizer,flag=wx.ALIGN_CENTER)
UpperBox.Add(UpperSizer,flag=wx.ALIGN_CENTER)
ControlSizer = wx.FlexGridSizer(3,1,1,1)
ControlSizer.Add(ComboBoxSizer,flag=wx.ALIGN_CENTER)
ControlSizer.Add(LowerBox,flag=wx.ALIGN_CENTER)
ControlSizer.Add(UpperBox,flag=wx.ALIGN_CENTER)
MainBox.Add(ControlSizer,flag=wx.ALIGN_CENTER)
self.sliders = [self.R_lower,self.G_lower,self.B_lower,
self.R_upper,self.G_upper,self.B_upper]
for slider in self.sliders:
slider.Bind(wx.EVT_SLIDER,self.OnAdjust)
self.ComboBox.Bind(wx.EVT_COMBOBOX, self.OnComboBox)
self.Bind(wx.EVT_CLOSE, self.OnExit)
self.SetSizer(MainBox)
self.Centre()
self.Fit()
self.Show(True)
self.GenerateFrame()
def main():
timeInterval = int(
ConfigManager.ConfigSectionMap("Basic_Conf")['timeinterval']
) ##Assign time interval into variable from config/config.ini file
threading.Timer(
timeInterval,
main).start() ## called main() function every 'timeInterval' seconds
cv2.useOptimized()
blnKNNTrainingSuccessful = DetectChars.loadKNNDataAndTrainKNN(
) # attempt KNN training
if blnKNNTrainingSuccessful == False: # if KNN training was not successful
print(
"\nerror: KNN traning was not successful\n") # show error message
return # and exit program
# end if
photo_path = CamManager.get_image() ##open camera and capture image
imgOriginalScene = cv2.imread(
"captured_img/last.png") # open captured image from directory
if imgOriginalScene is None: # if image was not read successfully
print("\nerror: image not read from file \n\n"
) # print error message to std out
os.system("pause") # pause so user can see error message
return # and exit program
# end if
listOfPossiblePlates = DetectPlates.detectPlatesInScene(
imgOriginalScene) # detect plates
listOfPossiblePlates = DetectChars.detectCharsInPlates(
listOfPossiblePlates) # detect chars in plates
if len(listOfPossiblePlates) == 0: # if no plates were found
print(
"\nno plates were detected\n") # inform user no plates were found
else: # else
# if we get in here list of possible plates has at leat one plate
# sort the list of possible plates in DESCENDING order (most number of chars to least number of chars)
listOfPossiblePlates.sort(
key=lambda possiblePlate: len(possiblePlate.strChars),
reverse=True)
# suppose the plate with the most recognized chars (the first plate in sorted by string length descending order) is the actual plate
licPlate = listOfPossiblePlates[0]
if len(licPlate.strChars) == 0: # if no chars were found in the plate
print("\nno characters were detected\n\n") # show message
return # and exit program
# end if
print("\ncharacters read from image = " + licPlate.strChars +
"\n") # write license plate text to std out
print("----------------------------------------")
mTime = datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'
) ##assign timestamp of measurement to variable 'mTime'
DBManager.insert_data(
mTime, int(licPlate.strChars), photo_path
) ##insert data into database; timestamp - measured data - photo path
# end if else
return
# -*- coding: utf-8 -*-
import cv2
import numpy as np
img1 = cv2.imread('../assets/lena.jpg')
e1 = cv2.getTickCount()
for i in xrange(5,49,2):
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print "cv2.useOptimized()=",cv2.useOptimized(),", time=",t
cv2.setUseOptimized(False)
e1 = cv2.getTickCount()
for i in xrange(5,49,2):
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print "cv2.useOptimized()=",cv2.useOptimized(),", time=",t
# cv2.getTickCount function returns the number of clock-cycles after a reference event (like the moment machine was switched ON)
# to the moment this function is called. So if you call it before and after the function execution, you get number of clock-cycles
# used to execute a function.
#
# cv2.getTickFrequency function returns the frequency of clock-cycles, or the number of clock-cycles per second. So to find the time
# of execution in seconds, you can do following:
import cv2
img1 = cv2.imread("pic.jpg")
e1 = cv2.getTickCount()
for i in xrange(5, 49, 2):
img1 = cv2.medianBlur(img1, i)
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print t
print cv2.useOptimized()
# -*- coding: utf-8 -*- import cv2 import numpy as np ''' OpenCV 中的默认优化 在编译时 优化是 默认开启的。因此 OpenCV 的就是优化后的代码 如果你把优化 关闭的 就只能执行低效的代码了。 你可以使用函数 cv2.useOptimized() 来查看优化是否 开启了 使用函数 cv2.setUseOptimized() 来开启优化 ''' # check if optimization is enabled """ In [5]: cv2.useOptimized() Out[5]: True In [6]: %timeit res = cv2.medianBlur(img,49) 10 loops, best of 3: 34.9 ms per loop # Disable it In [7]: cv2.setUseOptimized(False) In [8]: cv2.useOptimized() Out[8]: False In [9]: %timeit res = cv2.medianBlur(img,49) #优化后中值滤波的速度是原来的两倍 """ print(cv2.useOptimized()) cv2.setUseOptimized(False) print(cv2.useOptimized())
# ----------------------#
cv2.imshow('tmp',img1) #
cv2.waitKey(0) #
# ----------------------#
e1 = cv2.getTickCount()
for i in xrange(5,49,2):
# 中值模糊
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print t
# ----------------------#
cv2.imshow('tmp',img1) #
cv2.waitKey(0) #
# ----------------------#
# check if optimization is enabled
print cv2.useOptimized()
cv2.setUseOptimized(False)
print cv2.useOptimized()
e1 = cv2.getTickCount()
for i in xrange(5,49,2):
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print t
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print(t)
#python中的计算程序运行时间
start_time = time.time()
temp = 0
for i in range(1000):
temp = temp * i
end_time = time.time()
print(end_time - start_time)
'''
opencv中的默认优化
cv2.useOptimized()查看优化是否开启
cv2.setUseOptimized()开启优化
'''
print(cv2.useOptimized()) #检查优化是否开启
img = cv2.imread('logo.png')
e1 = cv2.getTickCount()
res = cv2.medianBlur(img, 49)
e2 = cv2.getTickCount()
print((e2 - e1) / cv2.getTickFrequency())
cv2.setUseOptimized(False) #关闭优化
e1 = cv2.getTickCount()
res = cv2.medianBlur(img, 49)
e2 = cv2.getTickCount()
print((e2 - e1) / cv2.getTickFrequency())
import cv2 as cv
import numpy as np
# 왜 최적화가 필요한가? 이미지처리에는 엄청나게 많은 연산이 진행되기 때문
# 배울 것
# cv.getTickCount
# cv.getTickFrequency
img = cv.imread("../1_arithmetic_operation/apple.jpg")
cv.setUseOptimized(True) # 기본 최적화 기능 on
for i in range(0, 2):
e1 = cv.getTickCount() # 코드 실행 시간
for i in range(5, 49, 2):
img = cv.medianBlur(img, i)
e2 = cv.getTickCount() # 코드 실행 종료 시간
t = (e2 - e1) * 1000 / cv.getTickFrequency() # 총 코드 실행 시간
print("Default OpenCV Optimization:", cv.useOptimized(), "\t", t, "ms")
cv.setUseOptimized(False) # 기본 최적화 기능 off
scipy.show_config();
# See http://docs.scipy.org/doc/numpy/reference/generated/numpy.set_printoptions.html
# We use 7 digits precision and suppress using scientific notation.
np.set_printoptions(precision=7, suppress=True, \
threshold=70000, linewidth=4000);
#threshold=7000000, linewidth=4000);
#threshold=7000, linewidth=300);
#threshold=1000000, linewidth=3000);
# Inspired from \OpenCV2-Python-Tutorials-master\source\py_tutorials\py_core\py_optimization
# normally returns True - relates to using the SIMD extensions of x86: SSX, AVX
common.DebugPrint("cv2.useOptimized() is %s" % str(cv2.useOptimized()));
if False:
cv2.setUseOptimized(True);
cv2.useOptimized();
"""
From http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html#checkhardwaresupport
CV_CPU_MMX - MMX
CV_CPU_SSE - SSE
CV_CPU_SSE2 - SSE 2
CV_CPU_SSE3 - SSE 3
CV_CPU_SSSE3 - SSSE 3
CV_CPU_SSE4_1 - SSE 4.1
CV_CPU_SSE4_2 - SSE 4.2
CV_CPU_POPCNT - POPCOUNT
import cv2 as cv
import numpy as np
img1 = cv.imread("Opencv/girl.png")
# cv.getTickCount 获取时间 从参考点开始 time.time()
# cv.getTickFrequency 获取时钟频率 （帧率）
e1 = cv.getTickCount()
for i in range(5, 49, 2):
img1 = cv.medianBlur(img1, i) # 中值滤波
e2 = cv.getTickCount()
time = (e2 - e1) / cv.getTickFrequency()
print(time)
# 函数优化 返回是否开启优化
print(cv.useOptimized())
# cv.setUseOptimized() 开启优化
# cv2.countNonZero() 和 np.count_nonzero()
cv.imshow("Image", img1)
cv.waitKey(0)
cv.destroyAllWindows()
img = cv.imread('../../datas/images/fish.jpg')
# 时间开始
e1 = cv.getTickCount()
for i in range(5, 49, 2):
img = cv.medianBlur(img, i)
# 时间结束
e2 = cv.getTickCount()
# 计算耗时
t = (e2 - e1) / cv.getTickFrequency()
print("operation time usage:", t) # operation time usage: 0.31588224549033933
# 判断Opencv是否已经使用优化功能
print(cv.useOptimized()) #True,表示已经启用
# 现在关闭优化功能
cv.setUseOptimized(False)
# 重新测试
# 时间开始
e1 = cv.getTickCount()
for i in range(5, 49, 2):
img = cv.medianBlur(img, i)
# 时间结束
e2 = cv.getTickCount()
# 计算耗时
t = (e2 - e1) / cv.getTickFrequency()
def main():
if(SAVE_CSV):
fp = open("output.log","w")
# is cv2 optimized
if(not cv2.useOptimized()):
cv.setUseOptimized(True)
logging.info("set optimized {0}".format(cv2.useOptimized()))
# CNN spatial input image scaling coeifficents
in_width = args.sizex #YOLO input
in_height = args.sizey
# 1/alpha
scale_factor = 1 / 255.0
# RGB mean substraction
RGB_mean = (0,0,0)
# swap RB channels
swapRB = True
# on object numbers
total_in_screen = 0
total_in = 0
total_out = 0
# track objects
tracked_objects = []
tracked_objs_in = []
tracked_objs_out = []
# capture the video stream
cap = cv2.VideoCapture(args.video)
# load labels names
labels = []
with open(args.labels, 'r') as f:
labels = [line.strip() for line in f.readlines()]
# create random color space for labels
COLORS = np.random.uniform(0, 255, size=(len(labels), 3))
# customized label list for filtering
filter_labels = ['person'] #labels
# to improve timing set flags
filter_label_active = [True if (itm in filter_labels) else False for itm in labels]
for idx,itm in enumerate(labels):
logging.debug(itm)
logging.debug(filter_label_active[idx])
# read DNN into cv2 dnn format
net = cv2.dnn.readNet(args.weights, args.config)
# identify output layer of the NN
output_layer = net.getUnconnectedOutLayersNames()
vid_init = None
vid_out=None
while (True):
start_t = cv2.getTickCount()
total_in_screen = 0
# Capture frame-by-frame
ret, frame = cap.read()
# use follwoing line if Umat
# ret, Oframe = cap.read()
if not ret:
logging.warning("failed to capture the frame")
break
# umat should make things faster but difficult to workwith in python
# should use C++ cuda
#frame = cv2.UMat(Oframe)
# resize the frame, convert it to grayscale, and blur it
frame = cv2.resize(frame, (in_height,in_width))
[frame_height, frame_width, *frame_rest] = frame.shape
# use follwoing line if Umat
#[frame_height, frame_width, *frame_rest] = Oframe.shape
if(VID_OUT and not vid_init):
vid_init = True
# opencv write video to a file.
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'XVID')
vid_out = cv2.VideoWriter('output.avi',fourcc, 20.0, (frame_width,frame_height))
# preprocessing the image to size for CNN spatial size
blob = cv2.dnn.blobFromImage(
frame, scale_factor, (in_width, in_height), RGB_mean, swapRB, crop=False)
# set DNN inputs with scaled values
net.setInput(blob)
# DNN forward propogation. Can use new Aync and optional [,output] for few OP detection
dnn_outputs = net.forward(output_layer)
# output filtration
conf_threshold = 0.5
nms_threshold = 0.4
label_idxs = []
boxes = []
confidences = []
# loop over each layer outputs
for dnn_output in dnn_outputs:
# loop over each detection of blobs
for detection in dnn_output:
# select the best label with highest output probability for blob
# first 4 indexes are blob dimensions
detection_val = detection[5:]
label_idx = np.argmax(detection_val)
if(not filter_label_active[label_idx]):
pass
else:
confidence = detection_val[label_idx]
if confidence > conf_threshold:
# add to total persons
total_in_screen+=1
# scale the bounding box to frame
(cx,cy,w,h) = map(int,detection[0:4]*np.array([frame_width,frame_height, frame_width,frame_height]))
x = int(cx - w / 2)
y = int(cy - h / 2)
# add predictions to lists for NMS normalization
label_idxs.append(label_idx)
confidences.append(float(confidence))
boxes.append([x, y, w, h])
# non-maxima suppression to suppress overlapping blobs/boxes
detects_normalized = cv2.dnn.NMSBoxes(
boxes, confidences, conf_threshold, nms_threshold)
# loop over detections left after normalization
for i in detects_normalized:
i = i[0]
[x,y,w,h,*rest] = boxes[i]
label = str(labels[label_idxs[i]])
color = COLORS[label_idxs[i]]
# mark center point of the objext
cv2.circle(frame, (int(cx), int(cy)), 1, (0, 0, 255), 5)
# draw a rectangle
cv2.rectangle(frame, (x, y), (x+w, y+h), color, 1)
# draw label
cv2.putText(frame, label, (x, y-15),cv2.FONT_HERSHEY_TRIPLEX, 0.4, color, 1)
if(SAVE_CSV):
fp.write("{},{},{},{},{},{}\n".format(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), label, cx, cy, w, h))
# tracking
# if no object is there
if(TRACK):
#tracking variables
max_move = frame_width//8
# divide the frame by 2 on x direction
margin_x = frame_width //2
margin_y = frame_height
obj_idx = 0
if (len(tracked_objects)==0):
tracked_objects.append(Track_Object(label_idxs[i], cx,cy))
# if objects are available
else:
match_found = False
for idx,track_object in enumerate(tracked_objects):
# check objects that were close for a match
dir_x = track_object.last_loc_x - cx
if (abs(dir_x)<max_move):
dir_y = track_object.last_loc_y - cy
if (abs(dir_y)<max_move):
track_object.dir_x=round(dir_x,2)
track_object.dir_y=round(dir_y,2)
track_object.last_loc_x=cx
track_object.last_loc_y=cy
obj_idx = idx
match_found = True
if(not match_found):
obj_idx = len(tracked_objects)
tracked_objects.append(Track_Object(label_idxs[i], cx,cy))
# print additional details about tracking and inward outward counts
#total_in = 0
#total_out = 0
for idx,track_object in enumerate(tracked_objects):
cv2.putText(frame, str(idx), (cx+15, cy-+15),cv2.FONT_HERSHEY_TRIPLEX, 0.4, color, 1)
track_details = "x` :{1} y`:{2}".format(idx,track_object.dir_x, track_object.dir_y)
cv2.putText(frame, track_details, (x, y-5),cv2.FONT_HERSHEY_TRIPLEX, 0.4, color, 1)
logging.debug(str(idx))
logging.debug(track_details)
track_details = "x :{1} y :{2}".format(idx,track_object.last_loc_x, track_object.last_loc_y)
logging.debug(track_details)
if(track_object.last_loc_x < margin_x and track_object.last_loc_x+track_object.dir_x > margin_x ):
# prevent double entry object already in cannot go again in
if(idx not in tracked_objs_in):
tracked_objs_in.append(idx)
if(idx in tracked_objs_out):
tracked_objs_out.remove(idx)
elif(track_object.last_loc_x > margin_x and track_object.last_loc_x+track_object.dir_x < margin_x ):
# prevent double entry
if(idx not in tracked_objs_out):
tracked_objs_out.append(idx)
if(idx in tracked_objs_in):
tracked_objs_in.remove(idx)
else:
# all the other objects that doesn't pass the boundry or stationary
pass
total_in = len(tracked_objs_in)
total_out = len(tracked_objs_out)
# draw a in out margin
cv2.line(frame, (margin_x,0),(margin_x, margin_y), (0,0,255), 1)
# fps calculation
fps = 1/((cv2.getTickCount()-start_t)/cv2.getTickFrequency())
# print values on frame
text_start_x = frame_width - 100
text_start_y = 30
text_seperation = 20
cv2.putText(frame, "Total: {}".format(str(total_in_screen)),
(text_start_x, text_start_y+text_seperation*1),
cv2.FONT_HERSHEY_TRIPLEX, 0.5, (255, 0, 0), 2)
if(TRACK):
cv2.putText(frame, "Inward: {}".format(str(total_in)),
(text_start_x, text_start_y+text_seperation*2),
cv2.FONT_HERSHEY_TRIPLEX, 0.5, (255, 0, 0), 2)
cv2.putText(frame, "Outward: {}".format(str(total_out)),
(text_start_x, text_start_y+text_seperation*3),
cv2.FONT_HERSHEY_TRIPLEX, 0.5, (255, 0, 0), 2)
cv2.putText(frame, "FPS: {}".format(str(round(fps,2))),
(text_start_x, text_start_y+text_seperation*4),
cv2.FONT_HERSHEY_TRIPLEX, 0.5, (255, 0, 0), 2)
cv2.imshow("Live Feed", frame)
if(VID_OUT):
vid_out.write(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# clean up release and distroy opencv windows
logging.info("cleaning up the app")
fp.close()
cap.release()
if (VID_OUT and vid_init):
vid_out.release()
cv2.destroyAllWindows()
import cv2
import numpy as np
import time
import timeit
img1 = cv2.imread('Images\messi.jpg')
time1 = time.time()
e1 = cv2.getTickCount(
) # Gives the no. of clock cycles till this function call
for i in xrange(5, 49, 2):
img1 = cv2.medianBlur(img1, i)
e2 = cv2.getTickCount()
time2 = time.time()
t = (e2 - e1
) / cv2.getTickFrequency() # Gives the number of clock cycles per second
print t # So it will print the execution time of above function
print time2 - time1
print time1
print cv2.useOptimized() # Check if optimization is enabled
time3 = time.time()
res = cv2.medianBlur(img1, 49)
time4 = time.time()
print "Optimized: " + str(time4 - time3)
cv2.setUseOptimized(False)
print cv2.useOptimized()
time3 = time.time()
res = cv2.medianBlur(img1, 49)
time4 = time.time()
print "Unoptimized: " + str(time4 - time3)
#!/usr/bin/env python
#!encoding=utf8
import cv2
import numpy as np
def test_medianBlur(img):
"""docstring for test_medianBlur"""
e1 = cv2.getTickCount()
for i in xrange(5, 49, 2):
img = cv2.medianBlur(img, i)
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print t
# cv2.imshow('medianBlur', img1)
# cv2.waitKey()
print 'Default useOptimized: ', cv2.useOptimized()
img = cv2.imread('demo2.png')
cv2.setUseOptimized(False)
print 'useOptimized: ', cv2.useOptimized()
test_medianBlur(np.copy(img))
cv2.setUseOptimized(True)
print 'useOptimized: ', cv2.useOptimized()
test_medianBlur(np.copy(img))
#提取log前景，其它部分黑色
img2_fg = cv2.bitwise_and(img2, img2, mask=mask)
#叠加
dst = cv2.add(img1_bg, img2_fg)
img1[0:rows, 0:cols] = dst
cv2.imshow("img2", img2)
cv2.imshow("mask", mask)
cv2.imshow("mask_inv", mask_inv)
cv2.imshow("img1_bg", img1_bg)
cv2.imshow("img2_fg", img2_fg)
cv2.imshow("img1", img1)
cv2.waitKey(0)
#性能优化
if 1:
if cv2.useOptimized() == False:
cv2.setUseOptimized(True)
img = cv2.imread("./fengjing.jpg", cv2.IMREAD_COLOR)
print("cv2.useOptimized() = ", cv2.useOptimized())
time_1 = time.time()
res = cv2.medianBlur(img, 49)
time_2 = time.time()
print("diff time = ", time_2 - time_1)
'''
e1 = cv2.getTickCount()
# your code execution
e2 = cv2.getTickCount()
time = (e2 - e1)/ cv2.getTickFrequency()
'''
img1 = cv2.imread('messi.png')
e1 = cv2.getTickCount()
for i in xrange(5,49,2):
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print t
# check if optimization is enabled
cv2.useOptimized()
# True
# %timeit res = cv2.medianBlur(img,49)
# 10 loops, best of 3: 34.9 ms per loop
# Disable it
cv2.setUseOptimized(False)
cv2.useOptimized()
# False
# %timeit res = cv2.medianBlur(img,49)
# 10 loops, best of 3: 64.1 ms per loop
def run(self):
# variables for syncing between threads
global frames
global timestamps
global frame_width
global frame_height
global trackingupdate
global quality
global outputQuality # of the cropped video
self.processed_frames = 0
self.success_frames = 0
self.error_frames = 0
# phone and screen constants
self.marker_size = 66 #rectangular (mm)
self.secondary_marker_size = 20
self.screen_height = int(config['DEFAULT']['screenHeightMM']) #mm
self.screen_width = int(config['DEFAULT']['screenHeightMM']) #mm
self.screen_pixel_height = int(config['DEFAULT']['screenHeightPX'])
self.screen_pixel_width = int(config['DEFAULT']['screenHeightPX'])
# precomputed calibration constants for the eyetracker
self.dist = numpy.array([[0.05357947, -0.22872005, -0.00118557, -0.00126952, 0.2067489 ]])
self.cameraMatrix = numpy.array([[1.12585498e+03, 0.00000000e+00, 9.34478069e+02], [0.00000000e+00, 1.10135217e+03, 5.84380561e+02], [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
self.mtx = numpy.array([[1.12825274e+03, 0.00000000e+00, 9.35684715e+02], [0.00000000e+00, 1.10801151e+03, 5.86151765e+02], [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
self.corner_refine_criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
directory = './out/{0}-{1}/'.format(self.participant, datetime.datetime.now().strftime("%Y-%m-%d"))
#directory = './out/2018-11-15-12-38/'
videoFilename_processed = 'gaze_video_processed.avi'
videoFilename_raw = 'gaze_video_raw.avi'
fourcc = cv2.VideoWriter_fourcc('M','J','P','G')
firstFrame = frames.get()
inputHeight, inputWidth, c = firstFrame.shape
out_processed = cv2.VideoWriter(directory + videoFilename_processed,fourcc, 25, (self.screen_pixel_width/outputQuality,self.screen_pixel_height/outputQuality))
out_raw = cv2.VideoWriter(directory + videoFilename_raw,fourcc, 25, (inputWidth,inputHeight))
cv2.useOptimized()
# open log files
computedFrames = open(directory + "/computed_frames.txt", "a+")
log = open(directory + 'log.txt', 'a+')
self.counter = 0 # used to execute functions only for every xth frame
self.logcounter = 0
while not (frames.qsize() == 0 and recording_flag == False):
if(not frames.empty()):
self.current_frame = frames.get()
# tobii format, yyyy-mm-dd-hh-mm-ss-ffffff
self.current_timestamp, self.current_absolute_timestamp = timestamps.get()
self.raw_frame = self.current_frame
self.current_frame = cv2.undistort(self.current_frame, self.mtx, self.dist, None, self.cameraMatrix)
frame_gray = cv2.cvtColor(self.current_frame, cv2.COLOR_BGR2GRAY) # aruco.detectMarkers() requires gray image
markers = cv2.aruco.detectMarkers(frame_gray,dictionary)
self.processed_frames += 1
if len(markers[0]) > 0:
# array order of corners is clockwise
corners, ids, rejectedImgPoints = markers
# get index of marker with id == 0
# bottom left == id1, bottom right = id3
try:
id0 = ids.tolist().index([0])
except:
# No marker with id == 0 detected
self.error_frames += 1
# print('markers detected but the main one is not amongst them.')
logstr = str(self.current_absolute_timestamp) + "; " + str(self.success_frames) + ' / ' + str(self.processed_frames) + '; ' + str(self.error_frames) + ' errors' + '; ' + str((float(self.error_frames) / float(self.processed_frames)) * float(100)) + '%; (' + str(frames.qsize()) + ' buffered'
self.logcounter += 1
if self.logcounter > 20:
log.write(logstr)
self.logcounter = 0
print(logstr)
self.counter += 1
if self.counter > 200:
self.counter = 0
cv2.imshow('frame',self.raw_frame)
cv2.waitKey(100)
continue
term = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1)
corners_id0 = cv2.cornerSubPix(frame_gray, corners[id0], (5, 5), (-1, -1), term)
rvec, tvec, objPoints = cv2.aruco.estimatePoseSingleMarkers(corners_id0, self.marker_size, self.cameraMatrix, self.dist) #tvec is the translation vector of the markers center
# corner estimation based on single big marker on the top of the screen
screenCorners = numpy.float32([
[-self.marker_size/2, -self.marker_size/2 - 1, 0],
[self.marker_size/2, -self.marker_size/2 - 1, 0],
[-self.marker_size/2,-self.marker_size/2 - (self.screen_height + 15) - 1,0],
[self.marker_size/2,-self.marker_size/2 - (self.screen_height + 15) - 1,0]
]).reshape(-1,3)
imgpts, jac = cv2.projectPoints(screenCorners, rvec, tvec, self.mtx, self.dist) #world coordinates to camera coordinates
#self.current_frame = cv2.aruco.drawAxis(self.current_frame, self.cameraMatrix, self.dist, rvec, tvec, 100)
screen_top_left = imgpts[0][0]
screen_top_right = imgpts[1][0]
screen_bottom_left = imgpts[2][0]
screen_bottom_right = imgpts[3][0]
id1 = None
id3 = None
# check if secondary markers were detected
try:
id1 = ids.tolist().index([1])
secondary_id = id1
except:
logstr = str(self.current_absolute_timestamp) + "; marker 1 not detected"
log.write(logstr)
pass
try:
id3 = ids.tolist().index([3])
secondary_id = id3
except:
logstr = str(self.current_absolute_timestamp) + "; marker 3 not detected"
log.write(logstr)
pass
# if one of them is detected: compute vector intersection
if id1 or id3 is not None:
corners_secondary = cv2.cornerSubPix(frame_gray, corners[secondary_id], (5, 5), (-1, -1), term)
rvec, tvec, objPoints = cv2.aruco.estimatePoseSingleMarkers(corners_secondary, self.secondary_marker_size, self.cameraMatrix, self.dist)
screenCorners = numpy.float32([ # bottom markers are upsidedown
[self.secondary_marker_size/2, -self.secondary_marker_size/2 - 1, 0],
[-self.secondary_marker_size/2, -self.secondary_marker_size/2 - 1, 0]
]).reshape(-1,3)
imgpts, jac = cv2.projectPoints(screenCorners, rvec, tvec, self.mtx, self.dist) #world coordinates to camera coordinates
secondary_marker_top_left = imgpts[0][0]
secondary_marker_top_right = imgpts[1][0]
# use coordinates themselves if all markers were detected
if id3 is not None:
screen_bottom_left = secondary_marker_top_left
screen_bottom_right = self.intersection(corners_id0[0][1],corners_id0[0][2],secondary_marker_top_left,secondary_marker_top_right)
else:
screen_bottom_right = secondary_marker_top_right
screen_bottom_left = self.intersection(corners_id0[0][0],corners_id0[0][3],secondary_marker_top_right,secondary_marker_top_left)
#self.current_frame = cv2.aruco.drawAxis(self.current_frame, self.cameraMatrix, self.dist, rvec, tvec, 100)
# self.drawCircle(self.current_frame, screen_top_left[0], screen_top_left[1])
# self.drawCircle(self.current_frame, screen_top_right[0], screen_top_right[1])
# self.drawCircle(self.current_frame, screen_bottom_left[0], screen_bottom_left[1])
# self.drawCircle(self.current_frame, screen_bottom_right[0], screen_bottom_right[1])
#Transform perspective according to QR code corner coordinates
pts1 = numpy.float32([screen_top_left, screen_top_right, screen_bottom_left, screen_bottom_right])
pts2 = numpy.float32([[0,0],[self.screen_pixel_width/outputQuality,0],[0,self.screen_pixel_height/outputQuality],[self.screen_pixel_width/outputQuality,self.screen_pixel_height/outputQuality]])
M = cv2.getPerspectiveTransform(pts1,pts2)
self.current_frame = cv2.warpPerspective(
self.current_frame,
M,
(self.screen_pixel_width/outputQuality,
self.screen_pixel_height/outputQuality)
)
trackingupdate.put((self.current_timestamp, self.current_absolute_timestamp, M))
computedFrames.write(
str(self.current_timestamp) + "; " +
self.current_absolute_timestamp + "; " +
str(screen_top_left) + '; ' +
str(screen_top_right) + '; ' +
str(screen_bottom_right) + '; ' +
str(screen_bottom_left) + '; ' +
str(M) + "\n"
)
out_processed.write(self.current_frame)
frames.task_done()
timestamps.task_done()
trackingupdate.task_done()
self.success_frames += 1
else:
#log frames without detected marker
log.write(str(self.current_absolute_timestamp) + "; no markers detected; " + str(self.current_timestamp) + '\n')
#command line feedback for success rate
self.error_frames +=1
out_raw.write(self.raw_frame)
logstr = str(self.current_absolute_timestamp) + "; " + str(self.success_frames) + ' / ' + str(self.processed_frames) + '; ' + str(self.error_frames) + ' errors' + '; ' + str((float(self.error_frames) / float(self.processed_frames)) * float(100)) + '%; (' + str(frames.qsize()) + ' buffered'
print(logstr)
self.logcounter += 1
if self.logcounter > 20:
log.write(logstr)
self.logcounter = 0
self.counter += 1
if self.counter > 200:
self.counter = 0
cv2.imshow('frame', self.raw_frame)
cv2.waitKey(100)
computedFrames.close()
log.close()
out_processed.release()
out_raw.release()
cv2.destroyAllWindows()
sys.exit(0)
