def test_vector_flow(a, b, c, max_angle=pi/32):
'''Tests a contiguous set of matches. The difference in angle between a-b
and b-c must be less than 'max_angle'. Default is difference of 5 degrees.
'''
try:
ab = array([b['x'] - a['x'], b['y'] - a['y']])
bc = array([c['x'] - b['x'], c['y'] - b['y']])
except ValueError:
ab = b-a
bc = c-b
vec = array([cv2.cartToPolar(r_[ab[0]], r_[ab[1]])[1].flatten(),
cv2.cartToPolar(r_[bc[0]], r_[bc[1]])[1].flatten()])
mins = min(vec,0)
vec -= mins
vec = max(vec,0)
vec[vec>pi] = 2*pi - vec[vec>pi]
gdvecs = vec < max_angle
divisor = sqrt(sum(ab[:2]**2,0))
nonzero = divisor != 0.
scalings = sqrt(sum(bc[:2]**2,0))/divisor
# print 'scales', scalings
meanscale = mean(sqrt(sum(bc[:2,nonzero]**2,0))/sqrt(sum(ab[:2,nonzero]**2,0)))
# print 'scale mean', meanscale
stdscale = std(sqrt(sum(bc[:2,nonzero]**2,0))/sqrt(sum(ab[:2,nonzero]**2,0)))
# print 'scale std', stdscale
gdscale = (scalings >= (meanscale-stdscale)) & (scalings <= (meanscale+stdscale))
return gdvecs & gdscale
def run_simple(self):
u'''Simple prediction'''
if len(self.datapath) >= 2:
# Use only two previous images
af_img = io.imread(self.datapath[0])
bf_img = io.imread(self.datapath[1])
#af_img = io.imread(r'./viptrafficof_02.png')
#bf_img = io.imread(r'./viptrafficof_03.png')
# Convert to gray image
af_gray = color.rgb2gray(af_img)
bf_gray = color.rgb2gray(bf_img)
# Calculate density flow
# Small -> WHY?
flow = cv2.calcOpticalFlowFarneback(bf_gray, af_gray, \
0.5, 6, 20, 10, 5, 1.2, 0)
print flow.shape, flow[:, :, 0].min(), flow[:, :, 1].max()
self.before = bf_gray
self.after = af_gray
#self.result = self.current
self.result = transform(af_img, flow)
# Color code the result for better visualization of optical flow.
# Direction corresponds to Hue value of the image.
# Magnitude corresponds to Value plane
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv = np.zeros_like(af_img)
hsv[...,1] = 255
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
self.optical = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
def gradient(image,bin_n=16): imageDim = np.prod(image.shape[:2]) gx = cv2.Sobel(image, cv2.CV_32F, 1, 0) gy = cv2.Sobel(image, cv2.CV_32F, 0, 1) mag, ang = cv2.cartToPolar(gx, gy) grad = np.hstack((mag.reshape(imageDim,3),ang.reshape(imageDim,3))) return grad
def hog(img, no_bins=16, orient=False):
"""
Calculates the normalised histogram of oriented gradient of a grayscale image.
Parameters
----------
no_bins: no of bins to be used
orient: If set to True, the function expects a
2D array of angles of gradient (in radians) corrosponding
to each pixel
"""
if not orient:
gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
bins = np.int32(no_bins * ang / (2 * np.pi))
elif orient:
bins = np.int32(no_bins * img / (2 * np.pi))
hist = cv2.calcHist([bins.astype("float32")], [0], None, [16], [0, 16])
hist = np.hstack(hist)
return (hist * 1000) / (img.shape[0] * img.shape[1])
def getGradientInfo(img):
sobelHorizontal = cv2.Sobel(img, ddepth = cv2.cv.CV_32F, dx = 1, dy = 0, ksize = 3)
sobelVertical = cv2.Sobel(img, ddepth = cv2.cv.CV_32F, dx = 0, dy = 1, ksize = 3)
magnitude, angle = cv2.cartToPolar(sobelHorizontal, sobelVertical)
# sobelHorizontal = cv2.convertScaleAbs(sobelHorizontal)
# sobelVertical = cv2.convertScaleAbs(sobelVertical)
# sobelHorizontal2 = cv2.convertScale(sobelHorizontal)
# sobelVertical2 = cv2.convertScale(sobelVertical)
# cv2.imshow("Threshold", cv2.addWeighted(sobelHorizontal, 0.5, sobelVertical, 0.5, 0))
# Quiver Plot
res = 10
N, M = img.shape
X, Y = np.meshgrid(np.arange(0, M, res), np.arange(0, N, res))
f = figure(1)
imshow(img, cmap=cm.gray)
# quiver(X, Y, sobelHorizontal[::res,::res], sobelVertical[::res,::res], units = "xy")
abc = cv2.addWeighted(sobelHorizontal, 0.5, sobelVertical, 0.5, 0)
print(abc.shape)
quiver(X, Y, cv2.transpose(sobelHorizontal)[::res,::res], cv2.transpose(sobelVertical)[::res,::res])
f.show()
return
def flow2hsv(self, flow):
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
self.hsv[...,0] = ang*self.ca
self.hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
bgr = cv2.cvtColor(self.hsv,cv2.COLOR_HSV2BGR)
return bgr
def chog(img): ''' Hand Contour Based Histograms of Oriented Gradients ''' img = ip.normalize(img) num_contours = 10 num_bins = 16 con = ip.hand_contour(img, num_contours) features = np.array([]) mid_x = img.shape[1] / 2 mid_y = img.shape[0] / 2 for i in range(1,num_contours+1): con_img = img.copy() con_img[con!=i] = 0 gx = cv2.Sobel(con_img, cv2.CV_32F, 1, 0) gy = cv2.Sobel(con_img, cv2.CV_32F, 0, 1) mag, ang = cv2.cartToPolar(gx, gy) bins = np.int32(num_bins*ang/(2*np.pi)) bin_cells = bins[:mid_y,:mid_x], bins[mid_y:,:mid_x], bins[:mid_y,mid_x:], bins[mid_y: mid_x:] mag_cells = mag[:mid_y,:mid_x], mag[mid_y:,:mid_x], mag[:mid_y,mid_x:], mag[mid_y: mid_x:] hists = [np.bincount(b.ravel(), m.ravel(), num_bins) for b, m in zip(bin_cells, mag_cells)] features = np.concatenate((features, np.hstack(hists))) return features
def shog(img): ''' Horizontally sliced histograms of Oriented Gradients ''' img = ip.normalize(img) # img = img.astype(float) num_slices = 10 num_bins = 16 slice_size = img.shape[0] / num_slices hists = [] # kx, ky = cv2.getDerivKernels(1,1,1) # kx = kx[::-1].transpose() # gx = cv2.filter2D(img, -1, kx, ) # gy = cv2.filter2D(img,-1, ky, cv2.CV_32F) gx = cv2.Sobel(img, cv2.CV_32F, 1, 0) gy = cv2.Sobel(img, cv2.CV_32F, 0, 1) mag, ang = cv2.cartToPolar(gx, gy) bins = np.int32(num_bins*ang/(2*np.pi)) for i in range(0, num_slices): bin_slice = bins[i*slice_size:i*slice_size+slice_size-1, :] mag_slice = mag[i*slice_size:i*slice_size+slice_size-1, :] hist = np.bincount(bin_slice.ravel(), mag_slice.ravel(), num_bins) hists.append(hist) # hists.append(hog(img[i*slice_size:i*slice_size+slice_size-1, :])) return np.hstack(hists)
def wing_lengths(wing_masks, wing_paths):
left_wing_length = right_wing_length = 0
height, width = wing_masks.shape[:2]
for path, name in zip(wing_paths, ['left', 'right']):
i, j = np.where(path == 255)
path_indices = [(y, x) for (y, x) in sorted(zip(i, j), key=lambda ind: ind[0]) if y > 0 and y < (height - 1) and x > 0 and x < (width - 1)]
if name == 'left':
cut_y, cut_x = [(y, x) for (y, x) in path_indices if np.sum(wing_masks[(y - 1):(y + 2), (x - 1):(x + 1)]) >= (3 * 255)][0]
wing = wing_masks[:cut_y, :cut_x]
xv, yv = np.meshgrid(np.arange(0, cut_x), np.arange(0, cut_y))
elif name == 'right':
cut_y, cut_x = [(y, x) for (y, x) in path_indices if np.sum(wing_masks[(y - 1):(y + 2), x:(x + 2)]) >= (3 * 255)][0]
wing = wing_masks[:cut_y, cut_x:]
xv, yv = np.meshgrid(np.arange(cut_x, width), np.arange(0, cut_y))
xv, yv = xv[np.where(wing == 255)], yv[np.where(wing == 255)]
if xv.size != 0 and yv.size != 0:
distance, _ = cv2.cartToPolar(xv.astype('float32') - cut_x, yv.astype('float32') - cut_y)
index = np.argmax(distance)
if name == 'left':
left_wing_length = distance[index, 0]
elif name == 'right':
right_wing_length = distance[index, 0]
return left_wing_length, right_wing_length
def hog(my_map, seg):
'''
my_map: map holding the image to extract features from
seg: Segmentation level to find features for
RETURNS:
HoG for each segment
Names of those features
'''
bins = 16
names = []
for i in range(bins):
names.append('hog {}'.format(i))
p = os.path.join('features', "color_edge_shapefilewithfeatures003-00{}-{}.npy".format(my_map.name[-1], seg))
if os.path.exists(p):
data = np.load(p)
else:
pbar = custom_progress()
bw_img = cv2.cvtColor(my_map.img, cv2.COLOR_RGB2GRAY)
gx = cv2.Sobel(bw_img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(bw_img, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
angles = ang/2.0*np.pi*255
segs = my_map.segmentations[seg].ravel()
n_segs = int(np.max(segs))+1
data = np.zeros((n_segs, 16), dtype = 'uint8')
for i in pbar(range(n_segs)):
indices = np.where(segs == i)[0]
data[i] = np.histogram(angles.ravel()[indices], 16)[0]
np.save(p, data)
return data, names
def preprocess_item_hist(img):
gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
bin_n = 16
bin = np.int32(bin_n*ang/(2*np.pi))
bin_cells = bin[:10,:10], bin[10:,:10], bin[:10,10:], bin[10:,10:]
mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
hist = np.hstack(hists)
# transform to Hellinger kernel
eps = 1e-7
hist /= hist.sum() + eps
hist = np.sqrt(hist)
hist /= norm(hist) + eps
# len(hist) = 64
# type(hist) = <type 'numpy.ndarray'>
# type(hist[0]) = <type 'numpy.float64'>
# hist[0] = 0.0
# print hist
# [ 0. 0. 0. 0. 0. 0. 0.
# 0. 0. 0. 0. 0. 0. 0.
# 0. 0. 0.02500444 0.03224029 0.0348727 0.05486763
# 0.05423923 0.05318612 0.09491311 0.13133056 0.07284845 0.0518625
# 0.04501667 0.08354647 0.07588132 0.03017876 0.0360361 0.0199627 0.
# 0. 0. 0. 0. 0. 0. 0.
# 0. 0. 0. 0. 0. 0. 0.
# 0. 0.21109739 0.23844386 0.2609863 0.28829302 0.29204482
# 0.23182723 0.18321263 0.20312054 0.18725011 0.26777668 0.24209061
# 0.25903133 0.27651589 0.25722604 0.23205954 0.20312469]
return hist
def process_optical_flow(video_path):
cap = cv2.VideoCapture(video_path)
ret, frame1 = cap.read()
frame1 = imutils.resize(frame1, width=800)
prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
prvs = cv2.GaussianBlur(prvs, (21, 21), 0)
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
while True:
ret, frame2 = cap.read()
frame2 = imutils.resize(frame2, width=800)
next_f = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
next_f = cv2.GaussianBlur(next_f, (21, 21), 0)
# flow = cv2.calcOpticalFlowFarneback(prvs, next, 0.5, 1, 3, 15, 3, 5, 1)
flow = cv2.calcOpticalFlowFarneback(prvs, next_f, 0.5, 3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('frame2', rgb)
k = cv2.waitKey(30) & 0xff
if k == ord('q'):
break
# elif k == ord('s'):
# cv2.imwrite('opticalfb.png', frame2)
# cv2.imwrite('opticalhsv.png', rgb)
prvs = next_f
cap.release()
cv2.destroyAllWindows()
def CalculateOpticalFlow(self, prev, nxt):
"""
Function definition
+++++++++++++++++++
.. py:function:: CalculateOpticalFlow(prev, nxt)
Computes a dense optical flow using the Gunnar Farneback’s algorithm using two subsequent
frames.
:param numpy_array prev: the first frame of the two subsequent frames.
:param numpy_array nxt: the second frame of the two subsequent frames.
"""
hsv = np.zeros((prev.shape[0], prev.shape[1], 3))
hsv[...,1] = 255
flow = cv2.calcOpticalFlowFarneback(prev,nxt, 0.5, 3, 15, 3, 5, 1.2, 0)
self.flow = flow
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1], angleInDegrees=1)
hsv[...,0] = ang/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
hsv = np.array(hsv, dtype=np.uint8)
self.motion_image = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
self.magnitude_image = hsv[...,2]
self.direction_image = ang
def test_optFlowPyrLK():
# Parameters for lucas kanade optical flow
lk_params = dict( winSize = (15,15),
maxLevel = 2,
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
cap = cv2.VideoCapture(0)
ret,frame = cap.read()
old_col = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame)
hsv[...,1] = 255
while(1):
ret,frame = cap.read()
frame_col = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(old_col,frame_col, 0.5, 3, 15, 3, 5, 1.2, 0)
old_col = frame_col.copy()
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
cv2.imshow('flow',rgb)
cap.release()
def dense_opt_flow(n_stills): #dense optical flow
cap = cv2.VideoCapture("test2.avi")
ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[...,1] = 255
while(1):
ret, frame2 = cap.read()
next = cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prvs,next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
cv2.imshow('frame2',bgr)
k = cv2.waitKey(1) & 0xff
if k == 27:
break
elif k == ord('s'):
cv2.imwrite('opticalfb.png',frame2)
cv2.imwrite('opticalhsv.png',bgr)
prvs = next
cap.release()
cv2.destroyAllWindows()
def preprocess_hog(digits):
samples = []
for img in digits:
gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
# bin_n = 16
bin_n = 1024
bin = np.int32(bin_n*ang/(2*np.pi))
n_rows = 2
n_cols = 2
bin_h = SZ / n_rows
bin_w = SZ / n_cols
bin_cells = list()
mag_cells = list()
for i in xrange(n_rows):
for j in xrange(n_cols):
bin_cells.append(bin[ (i-1)*bin_h : i*bin_h, (j-1)*bin_w : j*bin_w])
mag_cells.append(mag[ (i-1)*bin_h : i*bin_h, (j-1)*bin_w : j*bin_w])
# bin_w = SZ / 2
# bin_cells = [bin[:bin_w,:bin_w], bin[bin_w:,:bin_w], bin[:bin_w,bin_w:], bin[bin_w:,bin_w:]]
# mag_cells = [mag[:bin_w,:bin_w], mag[bin_w:,:bin_w], mag[:bin_w,bin_w:], mag[bin_w:,bin_w:]]
hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
hist = np.hstack(hists)
# transform to Hellinger kernel
# eps = 1e-7
# hist /= hist.sum() + eps
# hist = np.sqrt(hist)
# hist /= norm(hist) + eps
samples.append(hist)
return np.float32(samples)
def optical_flow(video_path):
cap = cv2.VideoCapture(video_path)
ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[...,1] = 255
while(1):
ret, frame2 = cap.read()
next = cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY)
#prev, next, scale, levels, winsize, ite, poly_n, poly_sigma
flow = cv2.calcOpticalFlowFarneback(prvs, next, 0.5, 1, 4, 3, 5, 1.1, cv2.OPTFLOW_FARNEBACK_GAUSSIAN)
# flow = cv2.calcOpticalFlowFarneback(prvs,next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
cv2.imshow('optflow',bgr)
cv2.imshow('orig', frame2)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
elif k == ord('s'):
cv2.imwrite('opticalfb.png',frame2)
cv2.imwrite('opticalhsv.png',bgr)
prvs = next
cap.release()
cv2.destroyAllWindows()
def histogramOfGradients(img):
'''
---
I:
O:
'''
import numpy as np
import cv2
# Calculate Sobel derivatives of each cell in x/y direction
gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
# Find magnitude/direction of gradient at each pixel
mag, ang = cv2.cartToPolar(gx, gy)
# Quantizing binvalues in (0...16)
bins = np.int32(bin_n*ang/(2*np.pi))
# Divide to 4 sub-squares
bin_cells = bins[:10,:10], bins[10:,:10], bins[:10,10:], bins[10:,10:]
mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
hists = [np.bincount(b.ravel(), m.ravel(), bin_n)
for b, m in zip(bin_cells, mag_cells)]
hist = np.hstack(hists)
return hist
def saliency_feature(img):
img_orig = img
img = cv2.resize(img, (64, 64))
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# h = cv2.getOptimalDFTSize(img.shape[0])
# w = cv2.getOptimalDFTSize(img.shape[1])
# print "Resizing (%d, %d) to (%d, %d)" % (img.shape[0], img.shape[1], h, w)
# h = (h - img.shape[0])/2.0
# w = (w - img.shape[1])/2.0
# img = cv2.copyMakeBorder(img, int(math.floor(h)), int(math.ceil(h)), int(math.floor(w)), int(math.ceil(w)), cv2.BORDER_CONSTANT, value=0)
dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
A, P = cv2.cartToPolar(dft[:,:,0], dft[:,:,1])
L = cv2.log(A)
h_n = (1./3**2)*np.ones((3,3))
R = L - cv2.filter2D(L, -1, h_n)
S = cv2.GaussianBlur(cv2.idft(np.dstack(cv2.polarToCart(cv2.exp(R), P)), flags=cv2.DFT_REAL_OUTPUT)**2, (0,0), 8)
S = cv2.resize(cv2.normalize(S, None, 0, 1, cv2.NORM_MINMAX), (img_orig.shape[1],img_orig.shape[0]))
# cv2.namedWindow('tmp1', cv2.WINDOW_NORMAL)
# cv2.imshow('tmp1', img_orig)
# cv2.namedWindow('tmp', cv2.WINDOW_NORMAL)
# cv2.imshow('tmp', S)
# cv2.waitKey()
return S
def calculate_integral_HOG(self, image):
# X, Y方向に微分
xsobel = np.zeros(image.shape)
filters.sobel(image,1,xsobel) # 1はaxis=1のこと = x方向
ysobel = np.zeros(image.shape)
filters.sobel(image,0,ysobel) # 1はaxis=0のこと = y方向
# 角度別の画像を生成しておく
bins = np.zeros((N_BIN, image.shape[0], image.shape[1]))
# X, Y微分画像を勾配方向と強度に変換
Imag, Iang = cv2.cartToPolar(xsobel, ysobel, None, None, True) # outputs are magnitude, angle
# 勾配方向を[0, 180)にする(181～360は0～180に統合する。x軸をまたいだ方向は考えない)
Iang = (Iang>180)*(Iang-180) + (Iang<=180)*Iang
Iang[Iang==360] = 0; Iang[Iang==180] = 0
# 勾配方向を[0, 1, ..., 8]にする準備（まだfloat）
Iang /= THETA
# 勾配方向を強度で重みをつけて、角度別に投票する
ind = 0
for ind in xrange(N_BIN):
bins[ind] += (np.int8(Iang) == ind)*Imag
# 角度別に積分画像生成
""" ！ここの計算があやしい！ """
integrals = np.array([cv2.integral(bins[i]) for i in xrange(N_BIN)])
return integrals
def hog(img, asHlist=True):
# Code from OpenCV examples.
# http://docs.opencv.org/trunk/doc/py_tutorials/py_ml/py_svm/py_svm_opencv/py_svm_opencv.html
bin_n = 9 # Number of bins
#grid_n = (12,20)
grid_n = (8,12)
gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
bins = np.int32(bin_n*ang/(2*np.pi)) # quantizing binvalues in (0...16)
bin_cells = []
mag_cells = []
rows, cols = img.shape[:2]
for i in xrange(grid_n[0]):
for j in xrange(grid_n[1]):
rs = slice(i*rows/grid_n[0], (i+1)*rows/grid_n[0])
cs = slice(j*cols/grid_n[1], (j+1)*cols/grid_n[1])
bin_cells.append(bins[rs, cs])
mag_cells.append(mag[rs, cs])
# bin_cells = bins[:10,:10], bins[10:,:10], bins[:10,10:], bins[10:,10:]
# mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
# [[bin1magSum,bin2magSum,...bin9magSum], [bin1magSum,bin2magSum,...,bin9magSum]]
hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
hist = np.hstack(hists) # hist is a 64 bit vector
if asHlist:
return hist / np.linalg.norm(hist)
else:
hists = np.reshape(hists,grid_n + (bin_n,))
return hists / np.linalg.norm(hist)
def solve_video():
cap = cv2.VideoCapture('ir.mp4')
ret, frame = cap.read()
prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
prev = cv2.GaussianBlur(prev, (5, 5), .7).astype(np.float32).view(hmarray)
hsv = np.zeros_like(frame)
hsv[..., 1] = 255
hm_u = hm.zeros_like(prev)
hm_v = hm.zeros_like(prev)
while True:
if frame is None:
break
curr = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
curr = cv2.GaussianBlur(curr, (5, 5), .7).astype(np.float32).view(hmarray)
hm_u, hm_v = hs_jacobi(prev, curr, hm_u, hm_v)
hm_u.sync_host()
hm_v.sync_host()
mag, ang = cv2.cartToPolar(hm_u, hm_v)
mag = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
ang = ang*180/np.pi/2
hsv[..., 0] = ang
hsv[..., 2] = mag
flow = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('flow', flow)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
prev = curr
cap.release()
def optical_flow_dense():
to_grayscale = lambda f: cv2.cvtColor(f, cv2.COLOR_BGR2GRAY)
params = dict(
pyr_scale=0.5,
levels=3,
winsize=15,
iterations=3,
poly_n=5,
poly_sigma=1.1,
flags=0
)
frames = gen_frames()
_frame = next(frames)
p_frame = to_grayscale(_frame)
hsv = np.zeros_like(_frame)
hsv[...,1] = 255
for frame in frames:
glayed = to_grayscale(frame)
# calculate optical flow
flow = cv2.calcOpticalFlowFarneback(p_frame, glayed, None, **params) # type: np.ndarray?
if flow is None:
print("none")
continue
# optical flow's magnitudes and angles
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX) # magnitude to 0-255 scale
frame = cv2.cvtColor(hsv,cv2.COLOR_HSV2RGB)
p_frame = glayed.copy()
yield frame
def process(frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.pyrDown(frame)
if d['prev'] is None:
d['prev'] = frame
# Computes a dense optical flow
# using the Gunnar Farneback’s algorithm
flow = cv2.calcOpticalFlowFarneback(d['prev'],
frame,
pyr_scale=0.5,
levels=1,
winsize=10,
iterations=1,
poly_n=5,
poly_sigma=1.1,
flags=0)
# Calculates the magnitude and angle of 2D vectors
mag, _ = cv2.cartToPolar(flow[..., 0], flow[..., 1])
# threshold it
_, mag = cv2.threshold(mag, 3, 255, cv2.THRESH_TOZERO)
# store the current frame
d['prev'] = frame
return mag
def solve_single_image():
frame0 = cv2.imread('images/frame0.png')
frame1 = cv2.imread('images/frame1.png')
im0 = cv2.cvtColor(frame0, cv2.COLOR_BGR2GRAY).astype(np.float32).view(hmarray)
im1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY).astype(np.float32).view(hmarray)
hm_u = hm.zeros_like(im0)
hm_v = hm.zeros_like(im0)
It = zeros_like(hm_u)
Iy = zeros_like(hm_u)
Ix = zeros_like(hm_u)
denom = zeros_like(hm_u)
new_u = zeros_like(hm_u)
new_v = zeros_like(hm_u)
hm_u, hm_v = hs_jacobi(im0, im1, hm_u, hm_v, Ix, Iy, It, denom, new_u, new_v)
hm_u.sync_host()
hm_v.sync_host()
mag, ang = cv2.cartToPolar(hm_u, hm_v)
mag = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
ang = ang*180/np.pi/2
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
hsv[..., 0] = ang
hsv[..., 2] = mag
flow = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('flow', flow)
cv2.waitKey()
def hog(img): """ Computes the HOG [histogram of oriented gradients] for an image Parameters ---------- img: np.ndarray input image (greyscale)- shape should be (H, W) Returns ------- Vector of shape (64, ) that describes the image using gradients """ gx = cv2.Sobel(img, cv2.CV_32F, 1, 0) gy = cv2.Sobel(img, cv2.CV_32F, 0, 1) mag, ang = cv2.cartToPolar(gx, gy) # quantizing binvalues in (0...16) bins = np.int32(bin_n*ang/(2*np.pi)) print(bins) # Divide to 4 sub-squares bin_cells = bins[:10,:10], bins[10:,:10], bins[:10,10:], bins[10:,10:] mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:] hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)] #(4, 16) hist = np.hstack(hists) #(4, 16) --> (64,) return hist
def opticalFlowCalc(input, input_pre, input_hsv):
flow = cv2.calcOpticalFlowFarneback(input, input_pre, 0.5, 3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
input_hsv[...,0] = ang*180/np.pi/2
input_hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
output = cv2.cvtColor(input_hsv,cv2.COLOR_HSV2BGR)
return output, input
def make_optFlow(fileName,BW):
print "Now processing: "+fileName.split("/")[5]
cap = cv2.VideoCapture(fileName)
#Start reading frames
ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[...,1] = 255
#Checking the number of frames in the video
length = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))
x = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))
y = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))
tmp = int(length / 30)
if(tmp==0):
tmp = 4
valid_frames = [tmp*i for i in xrange(0,length/tmp)]
#Open a videowriter object
fourcc = cv2.cv.CV_FOURCC(*'XVID')
if(not(BW)):
newFileName = "../../data/pre-process/optFlow_BW/"+fileName.split('/')[4]+"/"+fileName.split('/')[5].split('.')[0]+"_optFlow.avi"
out = cv2.VideoWriter(newFileName ,fourcc, 20, (x,y))
else:
newFileName = "../../data/pre-process/optFlow_BW/"+fileName.split('/')[4]+"/"+fileName.split('/')[5].split('.')[0]+"_BW_optFlow.avi"
out = cv2.VideoWriter(newFileName ,fourcc, 6, (x,y),0)
frame_num = 0
#Loop through all of the frames and calculate optical flow
while(1):
frame_num += 1
ret, frame2 = cap.read()
#If no more frames can be read then break out of our loop
if(not(ret)):
break
if(frame_num in valid_frames):
next = cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prvs,next, 0.5, 3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv,cv2.COLOR_HSV2RGB)
if(not(BW)):
out.write(rgb)
else:
bw = cv2.cvtColor(rgb,cv2.COLOR_RGB2GRAY)
out.write(bw)
prvs = next
#Close the file
cap.release()
out.release()
def demo(self):
'Demo for Optical flow, draw flow vectors and write to video'
with CaptureElement(self.video_path) as ce, WriteElement(self.video_path) as we:
pbar = startBar("Computing flow vectors", len(ce.frames))
hsv = np.zeros_like(ce.frames[0])
hsv[...,1] = 255
for n, img in enumerate(ce.frames):
# First run
if n < 1:
prev_frame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
current_frame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prev_frame, current_frame, 0.5, 3, 15, 3, 5, 1.2, 0)
# Reformatting for display
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
we.write_frame(rgb)
prev_frame = current_frame.copy()
pbar.update(n)
pbar.finish()
def _compare_frames(self, this_frame, prev_frame):
flow = cv2.calcOpticalFlowFarneback(
prev_frame, this_frame, pyr_scale=0.5, levels=3, winsize=2, iterations=3, poly_n=5, poly_sigma=1.2, flags=0
)
mag, _ = cv2.cartToPolar(flow[..., 0], flow[..., 1])
return mag
def HOGBikin(image):
# Read image
try:
visualise = True
image = numpy.atleast_2d(image)
height, width = image.shape
gx = numpy.zeros(image.shape)
gy = numpy.zeros(image.shape)
#robert
#gx[:, :-1] = numpy.diff(image, n=1, axis=1)
#gy[:-1, :] = numpy.diff(image, n=1, axis=0)
#prewitt
#for i in range(height): # 128
# for j in range(width): # 64
# if (i == 0) or (i == height - 1):
# gy[i, j] = 0
# else:
# gy[i, j] = image[(i + 1), j] - image[(i - 1), j]
#for i in range(height): # 128
# for j in range(width): # 64
# if (j == 0) or (j == width - 1):
# gx[i, j] = 0
# else:
# gx[i, j] = image[i, (j + 1)] - image[i, (j - 1)]
#magnitude = sqrt(gx ** 2 + gy ** 2)
#angle = arctan2(gy, (gx + 1e-15)) * (180 / pi)
#sobel
gx = cv2.Sobel(image, cv2.CV_32F, 1, 0, ksize=5)
gy = cv2.Sobel(image, cv2.CV_32F, 0, 1, ksize=5)
magnitude, angle = cv2.cartToPolar(gx, gy, angleInDegrees=True)
cell_size = 8
block_size = 2
orientations = 9
sx, sy = image.shape
cx, cy = (cell_size, cell_size)
bx, by = (block_size, block_size)
n_cellsx = int(numpy.floor(sx // cx)) # number of cells in x
n_cellsy = int(numpy.floor(sy // cy)) # number of cells in y
# compute orientations integral images
orientation_histogram = numpy.zeros((n_cellsx, n_cellsy, orientations))
temp_angle = numpy.zeros(shape=(sx, sy))
temp_mag = numpy.zeros(shape=(sx, sy))
for i in range(n_cellsx): #baris
for j in range(n_cellsy): #kolom
for o in range(orientations):
temp_bins = 0
for ii in range(i * cell_size, (i + 1) * cell_size):
for jj in range(j * cell_size, (j + 1) * cell_size):
temp_angle[ii, jj] = numpy.where(
angle[ii, jj] < 180 / orientations * (o + 1),
angle[ii, jj], 0)
temp_angle[ii, jj] = numpy.where(
angle[ii, jj] >= 180 / orientations * o,
temp_angle[ii, jj], 0)
# select magnitudes for those orientations
cond2 = temp_angle[ii, jj] > 0
temp_mag[ii,
jj] = numpy.where(cond2, magnitude[ii,
jj], 0)
temp_bins += temp_mag[ii, jj]
#print("temp_angle cell baris",i," kolom ",j," bins ",o)
#print(temp_angle)
#print("temp_mag cell baris", i, " kolom ", j, " bins ", o)
#print(temp_mag)
orientation_histogram[i, j, o] = temp_bins
#print(orientation_histogram[i, j, o])
hog_image = None
if visualise:
from skimage import draw
radius = min(cx, cy) // 2 - 1
orientations_arr = numpy.arange(orientations)
# set dr_arr, dc_arr to correspond to midpoints of orientation bins
orientation_bin_midpoints = (numpy.pi * (orientations_arr + .5) /
orientations)
dr_arr = radius * numpy.sin(orientation_bin_midpoints)
dc_arr = radius * numpy.cos(orientation_bin_midpoints)
hog_image = numpy.zeros((sx, sy), dtype=float)
for r in range(n_cellsx):
for c in range(n_cellsy):
for o, dr, dc in zip(orientations_arr, dr_arr, dc_arr):
centre = tuple([r * cx + cx // 2, c * cy + cy // 2])
rr, cc = draw.line(int(centre[0] - dc),
int(centre[1] + dr),
int(centre[0] + dc),
int(centre[1] - dr))
hog_image[rr, cc] += orientation_histogram[r, c, o]
n_blocksx = (n_cellsx - bx) + 1
n_blocksy = (n_cellsy - by) + 1
normalised_blocks = numpy.zeros(
(n_blocksx, n_blocksy, bx, by, orientations))
for x in range(n_blocksx):
for y in range(n_blocksy):
block = orientation_histogram[x:(x + bx), y:(y + by), :]
#print(block.shape)
eps = 1e-5
normalised_blocks[
x,
y, :] = block / numpy.sqrt(numpy.sum(block**2) + eps**2)
if visualise:
return normalised_blocks.ravel(), hog_image
else:
return normalised_blocks.ravel()
except:
print(traceback.format_exc())
pass
def run_yolo_prediction(args):
model = tf.keras.models.load_model(model_path)
net = cv2.dnn.readNet(weights_path, testing_cfg_path)
classes = []
with open(classes_path, "r") as f:
classes = f.read().splitlines()
# test with a video
if args['video']:
print(f"video used: {args['video']}")
cap = cv2.VideoCapture(f"./detection/input/{args['video']}")
# to save video
if args['save']:
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
if args['video']:
out = cv2.VideoWriter(f"./detection/output/out_{args['video']}", fourcc, 30.0, (540,960))
threshold = 0.5
ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[...,1] = 255
count = 0
up_bool = False
down_bool = False
first_up = False
frames = 0
# good_back = 0
# bad_back = 0
num_labels = 0
total_confidence = 0
form = 100.0
rep_form = []
prvs_labels = []
# Initialize text style
height, width, _ = frame1.shape
font = cv2.FONT_HERSHEY_SIMPLEX
fontScale = 2
fontColor = (255,255,255)
lineType = 2
bottomLeftCornerOfText = (10, int(height - (height / 40 + fontScale * height / 40)))
formPosition = (10, int(height - height / 40))
while True:
_,img = cap.read()
if img is None:
break
# 1. REP COUNTER
next = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Every 10 frames
if (frames % 10 == 0):
flow = cv2.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0) # What do these numbers represent?
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
rgb1 = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
rgb = rescale_frame(rgb1)
rgb = rgb.reshape((1,256,256,3))
prediction = model.predict(rgb, batch_size=1)
predict_label = np.argmax(prediction, axis=-1)
label = labels[int(predict_label)]
if len(prvs_labels) >= 3:
prvs_labels.pop(0)
prvs_labels.append(label)
# Identify first rep (two up frames in a row)
if prvs_labels[-2:] == ['up', 'up'] and not first_up:
first_up = True
# First down within the new rep
elif prvs_labels[-2:] == ['down', 'down'] and first_up:
down_bool = True
# First up within the new rep
elif prvs_labels[0] == 'down' and 'down' not in prvs_labels[-2:] and down_bool:
up_bool = True
# Reset and start a new rep
if up_bool and down_bool:
rep_form.append(form)
count += 1
up_bool = False
down_bool = False
num_labels = 0
total_confidence = 0
# good_back = 0
# bad_back = 0
form = 100.0
# Add count text
cv2.putText(img, f'Count: {count}', bottomLeftCornerOfText, font, fontScale, fontColor, lineType)
# Good form defined as more than 70% good labels within given rep
# Good form defined as an average confidence score of more than 0.5 within given rep
if (form >= 50):
formColor = [0,255,0]
else:
formColor = [0,0,255]
# Add form (%) text
cv2.putText(img, f'Form: {form}%', formPosition, font, fontScale, formColor, lineType)
# Add form summary text
for i in range(len(rep_form)):
# Add form for each completed rep
x = 10
y = int(height / 40 + i * fontScale * height / 40 * 0.7)
if rep_form[i] >= 50:
repColor = [0,255,0]
else:
repColor = [0,0,255]
cv2.putText(img, f'Rep {i+1}: {rep_form[i]}%', (x, y), font, int(fontScale * 0.7), repColor, lineType)
# 2. ROUNDED BACK DETECTION
height, width, _ = img.shape
blob = cv2.dnn.blobFromImage(img, 1/255, (416, 416), (0,0,0), swapRB=True, crop=False) #convert image to fit into the model
net.setInput(blob) #fit image into the model
output_layers_names = net.getUnconnectedOutLayersNames()
layerOutputs = net.forward(output_layers_names) #forward pass to get outputs
boxes = []
confidences = []
class_ids = []
for output in layerOutputs: # for each box segment
for detection in output: # for each object detected
# detection[0:3] first 4 values represents the bounding boxes, detection[4] confidence scores
scores = detection[5:]
class_id = np.argmax(scores)
confidence = scores[class_id]
if confidence > threshold:
center_x = int(detection[0]*width)
center_y = int(detection[1]*height)
w = int(detection[2]*width)
h = int(detection[3]*height)
x = int(center_x - w/2)
y = int(center_y - h/2)
boxes.append([x, y, w, h])
confidences.append((float(confidence)))
class_ids.append(class_id)
indexes = cv2.dnn.NMSBoxes(boxes, confidences, threshold, 0.4)
if len(indexes)>0 and first_up:
for i in indexes.flatten():
x, y, w, h = boxes[i]
label = str(classes[class_ids[i]])
confidence_score = round(confidences[i],2)
confidence = str(confidence_score)
# set red color for rounded back
if (label == 'rounded_back'):
# bad_back += 1
total_confidence += 1 - confidence_score
num_labels += 1
color = [0,0,255]
cv2.rectangle(img, (x,y), (x+w, y+h), color, 2)
cv2.putText(img, f'{label}', (x, y-35), font, 1, color, 2)
cv2.putText(img, f'{confidence}', (x, y-5), font, 1, color, 2)
# set green color for straight back
elif (label == 'straight_back'):
# good_back += 1
total_confidence += confidence_score
num_labels += 1
color = [0,255,0]
cv2.rectangle(img, (x,y), (x+w, y+h), color, 2)
cv2.putText(img, f'{label}', (x, y-35), font, 1, color, 2)
cv2.putText(img, f'{confidence}', (x, y-5), font, 1, color, 2)
# rep form (percentage of frames with good labels)
# form = round(good_back / (good_back + bad_back) * 100, 2)
# rep form (average confidence of good back within the rep)
form = round(total_confidence / num_labels * 100, 2)
img = cv2.resize(img,(540,960))
if args['save']:
out.write(img)
# cv2.imshow('Image', img)
key = cv2.waitKey(1)
if key==27:
break
prvs = next
frames += 1
cap.release()
cv2.destroyAllWindows()
# img = cv2.imread('clouds.jpg',0)
#
# # create a CLAHE object (Arguments are optional).
# clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
# cl1 = clahe.apply(img)
#
# cv2.imwrite('clahe_2.jpg',cl1)
# cv2.imshow(mat,'clahe_2.jpg')
# img_he = cv2.imread('clahe_2.jpg',0)
# cv2.imshow('clahe_2.jpg')
img = cv2.imread('tir_v1_0_8bit/trees/00000001.png', 0)
# cv2.imshow("input",img)
equ = cv2.equalizeHist(img)
# res = np.hstack((equ)) #stacking images side-by-side
# cv2.imshow("hist eq",equ)
cv2.imwrite('res.jpg', equ)
dft = cv2.dft(np.float32(equ), flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
magnitude_spectrum = 20 * np.log(
cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1]))
mag, angl = cv2.cartToPolar(dft_shift[:, :, 0], dft_shift[:, :, 1])
print(angl)
print(mag)
plt.subplot(121), plt.imshow(img, cmap='gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(magnitude_spectrum, cmap='gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
def getFarnebackOFVideo(srcVideoPath, grid_size):
"""
Function to get the Farneback dense optical flow features for the video file
and sample magnitude and angle features with a distance of grid_size between
two neighbours.
Copied and editted from shot_detection.py script
Parameters:
------
srcVideoPath: str
complete path of a video file
grid_size: int
distance between two consecutive sampling pixels.
Returns:
------
np.ndarray of dimension (N-1, 2 x (240/grid_size) x (320/grid_size))
"""
# get the VideoCapture object
cap = cv2.VideoCapture(srcVideoPath)
# if the videoCapture object is not opened then return None
if not cap.isOpened():
print("Error reading the video file !!")
return None
# dimensions = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), \
# int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
# totalFrames = cap.get(cv2.CAP_PROP_FRAME_COUNT)
frameCount = 0
features_current_file = []
ret, prev_frame = cap.read()
assert ret, "Capture object does not return a frame!"
prev_frame = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
# Iterate over the entire video to get the optical flow features.
while (cap.isOpened()):
frameCount += 1
ret, curr_frame = cap.read()
if not ret:
break
curr_frame = cv2.cvtColor(curr_frame, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prev_frame, curr_frame, None, 0.5,
3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
# stack sliced arrays along the first axis (2, (360/grid), (640/grid))
sliced_flow = np.stack(( mag[::grid_size, ::grid_size], \
ang[::grid_size, ::grid_size]), axis=0)
# For extracting only magnitude features, uncomment the following
#sliced_flow = mag[::grid_size, ::grid_size]
#feature.append(sliced_flow[..., 0].ravel())
#feature.append(sliced_flow[..., 1].ravel())
# saving as a list of float values (after converting into 1D array)
#features_current_file.append(sliced_flow.ravel().tolist()) #slow at load time
# convert to (1, 2x(H/grid)x(W/grid)) matrix.
sliced_flow = np.expand_dims(sliced_flow.flatten(), axis=0)
features_current_file.append(sliced_flow)
prev_frame = curr_frame
cap.release()
#print "{}/{} frames in {}".format(frameCount, totalFrames, srcVideoPath)
return np.array(features_current_file) # (N-1, 1, 2x(H/grid)x(W/grid))
def evaluation(img_akaze, img_circle):
##################################### PROGRAMMATIC ANALYSIS OF CHECK-POINTS #########################################
# load the image and convert it to grayscale
img_perfect = cv2.imread("team_id_2_comparison.png")
coordinates = [[29.5, 250.0], [38.0, 385.0], [160.97999572753906, 417.5],
[114.12354278564453, 338.9093322753906], [88.5, 259.0],
[158.53448486328125, 202.6724090576172], [187.5, 38.5],
[261.2481384277344, 121.8302230834961], [270.5, 243.0],
[291.4565124511719, 422.2826232910156],
[387.043701171875, 360.78155517578125], [343.0, 274.5],
[362.0, 166.5]]
feature_list = [636, 395, 1046, 500, 1605]
# programmatic checkpoints
circle_radius = 8
check_list = []
check_counter = 0
for i in coordinates:
i[0] = int(i[0])
i[1] = int(i[1])
roi = img_circle[i[1] - (3 * circle_radius):i[1] + (3 * circle_radius),
i[0] - (3 * circle_radius):i[0] + (3 * circle_radius)]
roi = roi.reshape(int(roi.size / 3), 3)
if [255, 255, 255] in roi.tolist():
check_list.append(1)
check_counter += 1
else:
check_list.append(0)
check_result = ((check_counter / check_list.__len__()) * 100)
print("Programmatic Analysis Result = ")
print(check_result)
####################################### ANALYSIS USING FEATURE MATCHING ##################################################
# load the image and convert it to grayscale
gray1 = cv2.cvtColor(img_perfect, cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(img_akaze, cv2.COLOR_BGR2GRAY)
# initialize the AKAZE descriptor, then detect keypoints and extract
# local invariant descriptors from the image
sift = cv2.xfeatures2d.SIFT_create()
surf = cv2.xfeatures2d.SURF_create()
akaze = cv2.AKAZE_create()
brisk = cv2.BRISK_create()
orb = cv2.ORB_create()
(akazekps1, akazedescs1) = akaze.detectAndCompute(gray1, None)
(akazekps2, akazedescs2) = akaze.detectAndCompute(gray2, None)
(siftkps1, siftdescs1) = sift.detectAndCompute(gray1, None)
(siftkps2, siftdescs2) = sift.detectAndCompute(gray2, None)
(surfkps1, surfdescs1) = surf.detectAndCompute(gray1, None)
(surfkps2, surfdescs2) = surf.detectAndCompute(gray2, None)
(briskkps1, briskdescs1) = brisk.detectAndCompute(gray1, None)
(briskkps2, briskdescs2) = brisk.detectAndCompute(gray2, None)
(orbkps1, orbdescs1) = orb.detectAndCompute(gray1, None)
(orbkps2, orbdescs2) = orb.detectAndCompute(gray2, None)
#print("No of KeyPoints:")
#print("akazekeypoints1: {}, akazedescriptors1: {}".format(len(akazekps1), akazedescs1.shape))
#print("akazekeypoints2: {}, akazedescriptors2: {}".format(len(akazekps2), akazedescs2.shape))
#print("siftkeypoints1: {}, siftdescriptors1: {}".format(len(siftkps1), siftdescs1.shape))
#print("siftkeypoints2: {}, siftdescriptors2: {}".format(len(siftkps2), siftdescs2.shape))
#print("surfkeypoints1: {}, surfdescriptors1: {}".format(len(surfkps1), surfdescs1.shape))
#print("surfkeypoints2: {}, surfdescriptors2: {}".format(len(surfkps2), surfdescs2.shape))
#print("briskkeypoints1: {}, briskdescriptors1: {}".format(len(briskkps1), briskdescs1.shape))
#print("briskkeypoints2: {}, briskdescriptors2: {}".format(len(briskkps2), briskdescs2.shape))
#print("orbkeypoints1: {}, orbdescriptors1: {}".format(len(orbkps1), orbdescs1.shape))
#print("orbkeypoints2: {}, orbdescriptors2: {}".format(len(orbkps2), orbdescs2.shape))
# Match the fezatures
bfakaze = cv2.BFMatcher(cv2.NORM_HAMMING)
bf = cv2.BFMatcher(cv2.NORM_L2)
akazematches = bfakaze.knnMatch(akazedescs1, akazedescs2, k=2)
siftmatches = bf.knnMatch(siftdescs1, siftdescs2, k=2)
surfmatches = bf.knnMatch(surfdescs1, surfdescs2, k=2)
briskmatches = bf.knnMatch(briskdescs1, briskdescs2, k=2)
orbmatches = bf.knnMatch(orbdescs1, orbdescs2, k=2)
# Apply ratio test on AKAZE matches
goodakaze = []
for m, n in akazematches:
if m.distance < 0.9 * n.distance:
goodakaze.append([m])
im3akaze = cv2.drawMatchesKnn(img_perfect,
akazekps1,
img_akaze,
akazekps2,
goodakaze[:100],
None,
flags=2)
cv2.imshow("AKAZE matching", im3akaze)
goodakaze = np.asarray(goodakaze)
print("akaze")
similarity_akaze = (goodakaze.shape[0] / feature_list[0]) * 100
print(similarity_akaze)
# Apply ratio test on SIFT matches
goodsift = []
for m, n in siftmatches:
if m.distance < 0.9 * n.distance:
goodsift.append([m])
im3sift = cv2.drawMatchesKnn(img_perfect,
siftkps1,
img_akaze,
siftkps2,
goodsift[:],
None,
flags=2)
cv2.imshow("SIFT matching", im3sift)
goodsift = np.asarray(goodsift)
print("sift")
similarity_sift = (goodsift.shape[0] / feature_list[1]) * 100
print(similarity_sift)
# Apply ratio test on SURF matches
goodsurf = []
for m, n in surfmatches:
if m.distance < 0.9 * n.distance:
goodsurf.append([m])
im3surf = cv2.drawMatchesKnn(img_perfect,
surfkps1,
img_akaze,
surfkps2,
goodsurf[:],
None,
flags=2)
cv2.imshow("SURF matching", im3surf)
goodsurf = np.asarray(goodsurf)
print("surf")
similarity_surf = (goodsurf.shape[0] / feature_list[2]) * 100
print(similarity_surf)
# Apply ratio test on ORB matches
goodorb = []
for m, n in orbmatches:
if m.distance < 0.9 * n.distance:
goodorb.append([m])
im3orb = cv2.drawMatchesKnn(img_perfect,
orbkps1,
img_akaze,
orbkps2,
goodorb[:],
None,
flags=2)
cv2.imshow("ORB matching", im3orb)
goodorb = np.asarray(goodorb)
print("orb")
similarity_orb = (goodorb.shape[0] / feature_list[3]) * 100
print(similarity_orb)
# Apply ratio test on BRISK matches
goodbrisk = []
for m, n in briskmatches:
if m.distance < 0.9 * n.distance:
goodbrisk.append([m])
im3brisk = cv2.drawMatchesKnn(img_perfect,
briskkps1,
img_akaze,
briskkps2,
goodbrisk[:],
None,
flags=2)
cv2.imshow("BRISK matching", im3brisk)
goodbrisk = np.asarray(goodbrisk)
print("brisk")
similarity_brisk = (goodbrisk.shape[0] / feature_list[4]) * 100
print(similarity_brisk)
features_result = (similarity_akaze + similarity_brisk + similarity_orb +
similarity_sift + similarity_surf) / 5
print("Overall similarity using features: ")
print()
######################################### HOG CORRELATION ###############################################
bin_n = 16
#img = cv2.imread("not_perfect_trajectory2.png")
gx = cv2.Sobel(img_perfect, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img_perfect, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
# quantizing binvalues in (0...16)
bins = np.int32(bin_n * ang / (2 * np.pi))
# Divide to 4 sub-squares
bin_cells = bins[:10, :10], bins[10:, :10], bins[:10, 10:], bins[10:, 10:]
mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]
hists = [
np.bincount(b.ravel(), m.ravel(), bin_n)
for b, m in zip(bin_cells, mag_cells)
]
hist1 = np.hstack(hists)
rows, cols, _ = img_akaze.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 0, 1)
img_akaze = cv2.warpAffine(img_akaze, M, (cols, rows))
gx = cv2.Sobel(img_akaze, cv2.CV_32F, 1, 0)
gy = cv2.Sobel(img_akaze, cv2.CV_32F, 0, 1)
mag, ang = cv2.cartToPolar(gx, gy)
# quantizing binvalues in (0...16)
bins = np.int32(bin_n * ang / (2 * np.pi))
# Divide to 4 sub-squares
bin_cells = bins[:10, :10], bins[10:, :10], bins[:10, 10:], bins[10:, 10:]
mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]
hists = [
np.bincount(b.ravel(), m.ravel(), bin_n)
for b, m in zip(bin_cells, mag_cells)
]
hist2 = np.hstack(hists)
hog_result = (np.corrcoef((hist1, hist2)[0][1]) * 100)
print("HOG CORRELATION RESULT = ")
print(hog_result)
return (check_result, features_result, hog_result)
cv2.imshow("image_akaze", img_akaze)
cv2.imshow("img_circle", img_circle)
cv2.waitKey(0)
hsv = np.zeros_like(frame1)
hsv[:, :, 1] = 255
flow = cv2.calcOpticalFlowFarneback(frame1_gray,
frame2_gray,
flow=None,
pyr_scale=0.5,
levels=3,
winsize=15,
iterations=3,
poly_n=5,
poly_sigma=1.2,
flags=0)
mag, ang = cv2.cartToPolar(flow[:, :, 0], flow[:, :, 1])
#angle of movement
hsv[:, :, 0] = ang * 180 / np.pi / 2
#strength of movement
hsv[:, :, 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite(path + "flow" + str(i) + ".jpg", rgb)
frame1_gray = frame2_gray
#%%
cv2.imwrite(path + "test.png", rgb[:, :, 2])
#%%
def extract_features(camera, align_mode=None):
preds = []
windowSize = 100
displacement = 0
figure = plt.figure(figsize=(10, 10))
ax = plt.axes(xlim=(0, 10), ylim=(340, 600))
#plt.xlim(0,10)
plt.ylim(0, 3)
plot_data, = ax.plot([], [])
plt.ion()
#aligner = FaceAligner()
#prvs = cv.cvtColor(frame1,cv.COLOR_BGR2GRAY)
prev = None
init_detect_pos = None
#plt.draw()
while camera.isOpened():
ret, frame = camera.read()
mean_mag = 0
if not ret:
break
orig_frame = frame.copy()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_detection.detectMultiScale(gray,
scaleFactor=1.5,
minNeighbors=5,
minSize=(100, 100),
maxSize=(300, 300),
flags=cv2.CASCADE_SCALE_IMAGE)
roi = None
roi_col = None
if align_mode == "facenet_align":
aligned = aligner.detect(frame)
if aligned is not None:
cv2.imshow('algined', aligned)
roi = cv2.cvtColor(aligned, cv2.COLOR_BGR2GRAY)
roi_col = aligned
#aligned = misc.imresize(cropped, (160, 160), interp='bilinear')
#dets = detector(orig_frame, 1)
if roi is None and len(faces) > 0:
face = faces[0]
x, y, w, h = face
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 255))
kernel = np.ones((5, 5), np.uint8) #cleanup a bit
orig_frame = cv2.dilate(orig_frame, kernel, iterations=1)
#extract roi, get region of interest
roi = gray[y:y + h, x:x + w]
roi_col = orig_frame[y:y + h, x:x + w]
if init_detect_pos is None or adjust_counter == re_adjust_frame:
init_detect_pos = x, y, w, h
adjust_counter = 0
else:
x, y, w, h = init_detect_pos
roi_col = orig_frame[y:y + h, x:x + w]
adjust_counter += 1
if roi is not None:
roi = cv2.resize(roi, (64, 64))
roi_col = cv2.resize(roi_col, (164, 164))
if prev is None:
prev = cv2.cvtColor(roi_col, cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(roi_col)
hsv[..., 1] = 255
print(hsv.shape)
else:
#nextImg = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
nextImg = cv2.cvtColor(roi_col, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prev, nextImg, None, 0.5,
3, 15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('optical_flow', bgr)
mean_mag = np.mean(mag)
xvals = np.arange(len(preds))
x_start = 0
x_end = 0
if len(xvals) > 0:
x_end = xvals[-1] + 3
x_start = x_end - windowSize + displacement
if x_start < 0:
x_start = 0
if (x_end < windowSize):
x_end = windowSize
ax.set_xlim(x_start, x_end)
#sc.set_offsets(np.c_[xvals,preds])
plot_data.set_data(xvals, preds)
figure.canvas.draw_idle()
plt.pause(0.01)
#plt.plot([0,0,1],[1,1,0])
#print(mean_mag)
prev = nextImg
#plt.plot()
#plt.draw()
#roi = roi.astype("float") / 255.0
#roi = img_to_array(roi)
#roi = np.expand_dims(roi, axis=0)
#print(label, emotion_probability, len(faces))
preds.append(mean_mag)
#output
cv2.imshow("Probabilities", frame)
if roi is not None:
cv2.imshow("Face", roi)
key = cv2.waitKey(1) & 0xFF
if key == ord('a'):
break
#cv2.imshow('your_face', frameClone)
#cv2.imshow("Probabilities", canvas)
#if cv2.waitKey(1) & 0xFF == ord('q'):
# break
plt.close("all")
camera.release()
return preds
import cv2
import numpy as np
img = cv2.imread('63063.jpg')
rows, cols = img.shape[:2]
exp = 1.5
scale = 1
mapy, mapx = np.indices((rows, cols), dtype=np.float32)
mapx = 2 * mapx / (cols - 1) - 1
mapy = 2 * mapy / (rows - 1) - 1
r, theta = cv2.cartToPolar(mapx, mapy)
r[r > scale] = r[r > scale]**exp
mapx, mapy = cv2.polarToCart(r, theta)
mapx = ((mapx + 1) * cols - 1) / 2
mapy = ((mapy + 1) * rows - 1) / 2
distorted = cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR)
cv2.imshow('dis', distorted)
cv2.waitKey()
cv2.destroyAllWindows()
def detect_video(yolo, video_path):
vid = cv2.VideoCapture(video_path)
if not vid.isOpened():
raise IOError("Couldn't open webcam or video")
accum_time = 0
curr_fps = 0
fps = "FPS: ??"
prev_time = timer()
#yolo.close_session()
#Optical flow initilize
return_value, old_frame = vid.read()
if(optical_flow_enable):
old_frame = cv2.resize(old_frame, (0,0), fx=0.4, fy=0.4)
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
# Create a mask image for drawing purposes
arrows = np.zeros_like(old_frame)
#Optical flow end
frameCount = 1
startFrame = 10
#bbox = (287, 23, 86, 320)
boxes = []
while True:
return_value, frame = vid.read()
frameCount += 1
if(optical_flow_enable):
frame = cv2.resize(frame, (0,0), fx=0.4, fy=0.4)
image = Image.fromarray(frame)
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
image, boxes = yolo.detect_image(image)
img = frame.copy()
#(boxes)
#Optical flow start=====================================================
# calculate optical flow
if(optical_flow_enable):
flow = cv2.calcOpticalFlowFarneback(old_gray, frame_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
arrows = np.zeros_like(frame)
mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
i = 0
mag_norm = cv2.normalize(mag, None, 0, 10, cv2.NORM_MINMAX)
# draw the tracks
"""for x in range(mag.shape[1]):
for y in range(mag.shape[0]):
ang_norm = ang[y][x] * 180 / (np.pi)
x2 = int(x + mag_norm[y][x] * math.cos(ang_norm))
y2 = int(y + mag_norm[y][x] * math.sin(ang_norm))
if(i % 50 == 0):
arrows = cv2.arrowedLine(arrows, (x, y), (x2, y2), color[1].tolist(), 1)
i += 1
img = cv2.add(frame,arrows)"""
img = np.asarray(img)
img, arrows = cropped_img(img, boxes, mag_norm, ang)
img = cv2.add(frame,arrows)
#cv2.imshow('frame',img)
# Now update the previous frame and previous points
old_gray = frame_gray.copy()
#Optical flow end=======================================================
#Yolo implementation ===================================================
result = np.asarray(image)
curr_time = timer()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
fps = "FPS: " + str(curr_fps)
curr_fps = 0
cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50, color=(255, 0, 0), thickness=2)
#cv2.namedWindow("result", cv2.WINDOW_NORMAL)
if(optical_flow_enable):
result = image_overlay(result, img, boxes)
cv2.imshow("result", result)
#Yolo implementation end ===============================================
if cv2.waitKey(1) & 0xFF == ord('q'):
break
yolo.close_session()
def bg_sub(filename, file_no, final_res):
try:
#filename='jogging/person16_jogging_d1_uncomp.avi'
ct = 0
res = []
cap = cv2.VideoCapture(filename)
n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
#print(n_frames)
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
lbp_res = np.ndarray(shape=(5, h, w))
feature_params = dict(maxCorners=100,
qualityLevel=0.3,
minDistance=7,
blockSize=7)
# Parameters for lucas kanade optical flow
lk_params = dict(winSize=(w, h),
maxLevel=2,
criteria=(cv2.TERM_CRITERIA_EPS
| cv2.TERM_CRITERIA_COUNT, 10, 0.03))
color = np.random.randint(0, 255, (100, 3))
#fourcc = cv2.VideoWriter_fourcc('*MJPG')
#videoout = cv2.VideoWriter(out_loc, fourcc, fps, (w, h))
_, frame = cap.read()
old_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
start_time = time.time()
p0 = cv2.goodFeaturesToTrack(old_frame, mask=None, **feature_params)
mask = np.zeros_like(frame)
ret, thresh = cv2.threshold(frame, 127, 255, 0)
fgbg = cv2.createBackgroundSubtractorMOG2()
for i in range(n_frames - 2):
ret, frame = cap.read()
if (ct < 5):
lbp1 = lbp(frame)
#print(lbp1.shape)
lbp_res[ct] = lbp1
ct = ct + 1
new_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if ret is False:
print("Cannot read video stream")
break
fgmask = fgbg.apply(new_frame)
fg_frame = np.float32(fgmask) / 255.0
gx = cv2.Sobel(fg_frame, cv2.CV_32F, 1, 0, ksize=1)
gy = cv2.Sobel(fg_frame, cv2.CV_32F, 0, 1, ksize=1)
mag, angle = cv2.cartToPolar(gx, gy, angleInDegrees=True)
if (i == 0):
sum_mag = np.zeros(shape=mag.shape, dtype=mag.dtype)
sum_angle = np.zeros(shape=angle.shape, dtype=angle.dtype)
sum_mag = np.add(sum_mag, mag)
sum_angle = np.add(sum_angle, angle)
else:
sum_mag = np.add(sum_mag, mag)
sum_angle = np.add(sum_angle, angle)
'''M = cv2.moments(fgmask)
if i==0:
init_cX=int(M["m10"] / M["m00"])
init_cY=int(M["m01"] / M["m00"])
cv2.circle(fgmask, (init_cX, init_cY), 5, (255, 255, 255), -1)
else:
if(M["m00"]==0)
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
cv2.circle(fgmask, (cX, cY), 5, (255, 255, 255), -1)
'''
p1, st, err = cv2.calcOpticalFlowPyrLK(old_frame, new_frame, p0,
None, **lk_params)
good_new = p1[st == 1]
good_old = p0[st == 1]
for j, (new, old) in enumerate(zip(good_new, good_old)):
a, b = new.ravel()
c, d = old.ravel()
cv2.line(fgmask, (a, b), (c, d), color[j].tolist(), 2)
cv2.circle(fgmask, (a, b), 2, color[j].tolist(), -1)
#print(angle.shape)
cv2.imshow('frame', fgmask)
# videoout.write(fgmask)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
end_time = time.time()
tot_time = end_time - start_time
hog_avg_mag = sum_mag / n_frames
hog_mag = hog_avg_mag.flatten()
#print(hog_mag.shape)
#print(hog_avg_mag)
hog_avg_angle = sum_angle / n_frames
hog_angle = hog_avg_angle.flatten()
#print(hog_angle.shape)
res = hog_mag + hog_angle
old_sum_X = 0
old_sum_Y = 0
new_sum_X = 0
new_sum_Y = 0
#print(good_new.shape)
#print(good_old.shape)
len1 = len(good_new)
for j, (new, old) in enumerate(zip(good_new, good_old)):
a, b = new.ravel()
c, d = old.ravel()
old_sum_X = old_sum_X + c
old_sum_Y = old_sum_Y + d
new_sum_X = new_sum_X + a
new_sum_Y = new_sum_Y + b
old_sum_X = old_sum_X / len1
old_sum_Y = old_sum_Y / len1
new_sum_X = new_sum_X / len1
new_sum_Y = new_sum_Y / len1
disp_opt = math.sqrt(
((old_sum_X - new_sum_X)**2 + (old_sum_Y - new_sum_Y)**2))
#disp=math.sqrt(((init_cX-cX)**2+(init_cY-cY)**2))
#velocity=disp/tot_time
velocity_opt = disp_opt / tot_time
#print(disp)
#print(disp_opt)
#print(velocity)
#print(velocity_opt)
res = list(res)
res.append(disp_opt)
res.append(velocity_opt)
# lbp_res=np.array(lbp1)
lbp_res = lbp_res.flatten()
lbp_res = list(lbp_res)
# print(lbp_res)
# print(lbp_res.shape)
res = [*res, *lbp_res]
# res=list(res)
res = np.array(res)
featuresize = len(res)
print(featuresize)
final_res[file_no] = res
cap.release()
# videoout.release()
cv2.destroyAllWindows()
except LookupError:
print("Error")
import cv2
import os
import numpy as np
path = '/home/eshwarmannuru/Desktop/NumberPlateDetection/result/1/1.png'
path = sys.argv[1]
im = cv2.imread(path)
#print(im.shape)
im = np.float32(im) / 255.0
gx = cv2.Sobel(im, cv2.CV_32F, 1, 0, ksize = 1)
gy = cv2.Sobel(im, cv2.CV_32F, 0, 1, ksize = 1)
mag, angle = cv2.cartToPolar(gx, gy, angleInDegrees=True)
cv2.imshow("Mag",mag)
hog = cv2.HOGDescriptor()
img = hog(im)
"""
cv2.imshow("Image",im)
from pytesseract import image_to_string
from PIL import Image
print(image_to_string(Image.open(path)))
while (ret):
index += 1
flow = cv2.calcOpticalFlowFarneback(
prvs,
next,
None,
pyr_scale=0.5, # Taux de réduction pyramidal
levels=3, # Nombre de niveaux de la pyramide
winsize=
15, # Taille de fenêtre de lissage (moyenne) des coefficients polynomiaux
iterations=3, # Nb d'itérations par niveau
poly_n=7, # Taille voisinage pour approximation polynomiale
poly_sigma=1.5, # E-T Gaussienne pour calcul dérivées
flags=0)
mag, ang = cv2.cartToPolar(flow[:, :, 0],
flow[:, :,
1]) # Conversion cartésien vers polaire
hsv[:, :, 0] = (ang * 180) / (
2 * np.pi) # Teinte (codée sur [0..179] dans OpenCV) <--> Argument
hsv[:, :, 2] = (mag * 255) / np.amax(mag) # Valeur <--> Norme
bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
result = np.vstack((frame2, bgr))
cv2.imshow('Image et Champ de vitesses (Farnebäck)', result)
k = cv2.waitKey(15) & 0xff
if k == 27:
break
elif k == ord('s'):
cv2.imwrite('Frame_%04d.png' % index, frame2)
cv2.imwrite('OF_hsv_%04d.png' % index, bgr)
prvs = next
print("remapping...")
newf = cv2.remap(ext,
mx,
my,
cv2.INTER_CUBIC,
cv2.BORDER_CONSTANT,
borderValue=255)
name = sys.argv[2]
print("writing result file ", name, "...")
cv2.imwrite(name, newf)
if len(sys.argv) > 4:
print("beautifying...")
mag, ang = cv2.cartToPolar(cx, cy)
hsv = np.zeros((ext.shape[0], ext.shape[1], 3), dtype=np.uint8)
### for color: fill ch.1 white
hsv[..., 1].fill(255)
# hsv[...,0] = ang * 180 / np.pi / 2
## careful: normalised in each transformation on its own!
hsv[..., 0] = cv2.normalize(ang * 180 / np.pi / 2, None, 0, 255,
cv2.NORM_MINMAX)
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
name = sys.argv[4]
print("writing local distortion visualization %s..." % name)
cv2.imwrite(name, bgr)
print("global transform...")
def dense(self,
filename='',
pyr_scale=0.5,
levels=3,
winsize=15,
iterations=3,
poly_n=5,
poly_sigma=1.2,
flags=0,
skip_empty=False):
"""
Renders a dense optical flow video of the input video file using `cv2.calcOpticalFlowFarneback()`.
For more details about the parameters consult the cv2 documentation.
Parameters
----------
- filename : str, optional
Path to the input video file. If not specified the video file pointed to by the MgObject is used.
- pyr_scale : float, optional
Default is 0.5.
- levels : int, optional
Default is 3.
- winsize : int, optional
Default is 15.
- iterations : int, optional
Default is 3.
- poly_n : int, optional
Default is 5.
- poly_sigma : float, optional
Default is 1.2.
- flags : int, optional
Default is 0.
- skip_empty : bool, optional
Default is `False`. If `True`, repeats previous frame in the output when encounters an empty frame.
Outputs
-------
- `filename`_flow_dense.avi
Returns
-------
- MgObject
A new MgObject pointing to the output '_flow_dense' video file.
"""
if filename == '':
filename = self.filename
of = os.path.splitext(filename)[0]
fex = os.path.splitext(filename)[1]
vidcap = cv2.VideoCapture(filename)
ret, frame = vidcap.read()
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
fps = int(vidcap.get(cv2.CAP_PROP_FPS))
width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
out = cv2.VideoWriter(of + '_flow_dense' + fex, fourcc, fps,
(width, height))
ret, frame1 = vidcap.read()
prev_frame = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
ii = 0
while (vidcap.isOpened()):
ret, frame2 = vidcap.read()
if ret == True:
next_frame = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prev_frame, next_frame,
None, pyr_scale, levels,
winsize, iterations,
poly_n, poly_sigma, flags)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
if skip_empty:
if np.sum(rgb) > 0:
out.write(rgb.astype(np.uint8))
else:
out.write(prev_rgb.astype(np.uint8))
else:
out.write(rgb.astype(np.uint8))
prev_frame = next_frame
prev_rgb = rgb
else:
mg_progressbar(length, length,
'Rendering dense optical flow video:',
'Complete')
break
ii += 1
mg_progressbar(ii, length + 1,
'Rendering dense optical flow video:', 'Complete')
out.release()
source_audio = extract_wav(of + fex)
destination_video = of + '_flow_dense' + fex
embed_audio_in_video(source_audio, destination_video)
os.remove(source_audio)
return mgmodule.MgObject(destination_video,
color=self.color,
returned_by_process=True)
current_path = os.path.join(image_dir, k, current)
prev_image = cv.imread(prev_path)
current_image = cv.imread(current_path)
prev_gray = cv.cvtColor(prev_image, cv.COLOR_BGR2GRAY)
current_gray = cv.cvtColor(current_image, cv.COLOR_BGR2GRAY)
mask = np.zeros_like(current_image)
hsv_current = cv.cvtColor(current_image, cv.COLOR_RGB2HSV)
mask[:,:,1] = hsv_current[:,:,1]
flow = cv.calcOpticalFlowFarneback(prev_gray, current_gray, None, 0.5, 1, 15, 2, 5, 1.3, 0)
magnitude, angle = cv.cartToPolar(flow[..., 0], flow[..., 1])
mask[..., 0] = angle * (180 / np.pi / 2)
mask[..., 2] = cv.normalize(magnitude, None, 0, 255, cv.NORM_MINMAX)
rgb = cv.cvtColor(mask, cv.COLOR_HSV2BGR)
cv.imwrite(os.path.join(parent_folder, f'{k}-{j}.png'), rgb)
of_map.setdefault(k, []).append((f'{k}-{j}.png', speed))
num_processed += 1
pkl.dump(of_map, open(os.path.join(of_dir, f'optical_flow_map_{mode}.pkl'), 'wb'))
pkl.dump(new_files, open(os.path.join(of_dir, f'new_files_{mode}.pkl'), 'wb'))
def compute(offset, end):
CONFIG["output_compressed_file"] = "optical_flow{}-{}.tar.gz".format(
offset, end)
video = Video(CONFIG["input_video_file"])
compressed_file = None
tmp_dir = None
if CONFIG["create_compressed_file"]:
tmp_dir = tempfile.TemporaryDirectory()
compressed_file = tarfile.open(CONFIG["output_compressed_file"],
"w:gz")
for current_frame_n in range(offset, end):
try:
crnt = video[current_frame_n]
nxt = video[current_frame_n + 1]
except StopIteration:
break
print("Meow")
hsv = np.zeros(crnt.shape, dtype=np.uint8)
crnt = cv2.cvtColor(crnt, cv2.COLOR_BGR2GRAY)
nxt = cv2.cvtColor(nxt, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(
crnt,
nxt,
flow=None,
pyr_scale=0.2,
levels=5,
winsize=25,
iterations=2,
poly_n=10,
poly_sigma=1.2,
flags=cv2.OPTFLOW_FARNEBACK_GAUSSIAN)
hsv[:, :, 0] = 255
hsv[:, :, 1] = 255
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite("meow.jpg", rgb)
cv2.imshow("meow", rgb)
cv2.waitKey(0)
cv2.destroyAllWindows()
if CONFIG["display_optical_flow"]:
cv2.imshow("Optical Flow", opt)
cv2.waitKey(0)
cv2.destroyAllWindows()
if CONFIG["create_compressed_file"]:
cv2.imwrite(
"{}/optical_flow{}-{}.jpg".format(tmp_dir.name,
current_frame_n,
current_frame_n + 1), opt)
print("Counter #", current_frame_n)
os.chdir(tmp_dir.name)
if CONFIG["create_compressed_file"]:
for _files in glob.glob("*".format(tmp_dir.name)):
compressed_file.add(_files, recursive=False)
compressed_file.close()
tmp_dir.cleanup()
def runOptFlow(self, frame0, frame1, participants):
# https://docs.opencv.org/4.0.1/dc/d6b/group__video__track.html#ga5d10ebbd59fe09c5f650289ec0ece5af
# (..., ..., ..., pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags )
# pyr_scale = .5 means each next layer is .5 the size of the previous.
# levels, number of layers
# winsize, larger is smoother and faster but lower res
# iterations, ...
# poly_n, typically 5 or 7
# poly_sigma, 1.1 or 1.5
# flags, extra options
flow = cv2.calcOpticalFlowFarneback(self.frame0, self.frame1, None, .5,
0, self.of_fb_winsize, 1, 5, 1.1,
0)
# average angle
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv = np.zeros_like(self.frame00)
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = mag
# Find the mean vector.
flow[mag < self.mag_threshold, 0] = 0
flow[mag < self.mag_threshold, 1] = 0
# Work out the x/y and mag/angle components of each participant
for item in participants:
# Split the data on x and then y. Doing this in one command crashes the code for some obscure reason
fl2 = flow[:, item.xRange, :]
fl2 = fl2[item.yRange, :, :]
item.X = np.nanmean(fl2[:, :, 0])
item.Y = np.nanmean(fl2[:, :, 1])
item.XYmag = (np.sqrt(item.X**2 + item.Y**2))
item.XYang = (np.arctan2(item.Y, item.X))
if item.XYang < 0:
item.XYang = np.mod(item.XYang, np.pi) + np.pi
if len(participants) >= 2:
# Get the relative angle between the first two participents
relAng = np.mod(
np.subtract(participants[0].XYang, participants[1].XYang),
2 * np.pi)
xrel, yrel = cv2.polarToCart(1, relAng)
else:
xrel, yrel = 0, 0
# # Experiment with the scaling and thresholding to map motion b/w 0 and 255.
mag[mag < self.mag_threshold] = 0
mag = mag * 10
if np.max(np.abs(mag)) > 255:
print(np.max(np.abs(mag)))
hsv[..., 2] = mag
# I don't remember any more why I commented this out. Oh yeah. You want to be able to tell how much movement is detected, and how fast, from the video.
# hsv[...,2] = cv2.normalize(mag,None,alpha=0,beta=255,norm_type=cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.putText(bgr,
datetime.datetime.now().strftime("%A %d %B %Y %I:%M:%S%p"),
(10, bgr.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35,
(0, 0, 255), 1)
cv2.circle(bgr,
self.center,
self.feedback_circle_r, (25, 25, 25, 1),
thickness=1)
cv2.setMouseCallback("Camera", self.boxSelect)
camImg = self.frame01.copy()
for i, item in enumerate(participants):
cv2.rectangle(camImg, (item.xRange[0], item.yRange[0]),
(item.xRange[-1], item.yRange[-1]),
item.color,
thickness=2)
# Either display individual velocity vectors or the relative phase.
if self.REL_PHASE_FEEDBACK == 1:
cv2.line(bgr,
self.center,
(int(self.center[0] + xrel[0] * self.feedback_circle_r),
int(self.center[1] + yrel[0] * self.feedback_circle_r)),
(200, 200, 250, 1),
thickness=2)
else:
for item in self.participents:
cv2.line(
bgr,
self.center,
(int(self.center[0] + item.X * self.feedback_circle_r),
int(self.center[1] + item.Y * self.feedback_circle_r)),
item.color,
thickness=2)
cv2.imshow("Camera", camImg)
if self.ANY_FEEDBACK:
cv2.imshow('Dense optic flow', bgr)
self.TIME.append(time.time() - self.TIME[0])
def main():
stepCounter = 0
synchron = False
robot = EPuckVRep('ePuck', port=19999, synchronous=synchron)
if synchron:
robot.startsim()
robot.enableAllSensors()
robot.enableCamera()
robot.setImageCycle(1)
robot.setSensesAllTogether(
True
) # we want fast sensing, so set robot to sensing mode where all sensors are sensed
# get initial image from robot
resolX, resolY = 64, 64
# get initial image
open_cv_image = getOpenCVCameraImage(robot.getCameraImage(), resolX,
resolY)
# Convert the new image to gray
prvsGray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
magNew = angNew = mag = ang = 0
noChangeCount = 0
first = True
# main sense-act cycle
while robot.isConnected():
# Get sensor values and camera image
robot.fastSensingOverSignal()
proxSensors = robot.getProximitySensorValues()
open_cv_image = getOpenCVCameraImage(robot.getCameraImage(), resolX,
resolY)
noDetectionDistance = 0.05 * robot.getS()
# Convert the new image to gray
nextGray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
#cv2.imshow('Gray', nextGray)
if prvsGray is not None and next is not None:
flow = cv2.calcOpticalFlowFarneback(prvsGray, nextGray, None, 0.5,
3, 15, 3, 5, 1.2, 0)
# get angle and magnitude
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
ret, mask = cv2.threshold(mag, 2, 1, cv2.THRESH_BINARY)
cv2.multiply(mag, mask, mag)
cv2.multiply(ang, mask, ang)
mag = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
ang = ang * 180 / np.pi
# Check if flow is detected
if np.any(mag[:, :] > 0) or np.any(
ang[:, :] > 0) or noChangeCount > 4 or first == True:
first = False
noChangeCount = 0
magNew = mag
angNew = ang
prvsGray = nextGray
else:
noChangeCount += 1
# show image
hsv = np.zeros_like(open_cv_image)
hsv[..., 1] = 255
hsv[..., 0] = angNew * 180 / np.pi / 2
hsv[..., 2] = magNew
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
res = cv2.resize(rgb,
None,
fx=6,
fy=6,
interpolation=cv2.INTER_CUBIC)
cv2.imshow('flow', res)
leftMotor, rightMotor = calculateMotorValues(magNew, angNew,
proxSensors)
# to abort controller
k = cv2.waitKey(1) & 0xff
if k == 27:
break
robot.setMotorSpeeds(leftMotor, rightMotor)
if synchron:
robot.stepsim(1)
robot.disconnect()
## 좌우 대칭 거울 좌표 연산 map_mirrorh_x[:, cols // 2:] = cols - map_mirrorh_x[:, cols // 2:] - 1 ## 상하 대칭 거울 좌표 연산 map_mirrorv_y[rows // 2:, :] = rows - map_mirrorv_y[rows // 2:, :] - 1 # 물결 효과 map_wave_x, map_wave_y = map_x.copy(), map_y.copy() map_wave_x = map_wave_x + 15 * np.sin(map_y / 20) map_wave_y = map_wave_y + 15 * np.sin(map_x / 20) # 렌즈 효과 ## 렌즈 효과, 중심점 이동 map_lenz_x = (2 * map_x - cols) / cols map_lenz_y = (2 * map_y - rows) / rows ## 렌즈 효과, 극좌표 변환 r, theta = cv2.cartToPolar(map_lenz_x, map_lenz_y) r_convex = r.copy() r_concave = r ## 볼록 렌즈 효과 매핑 좌표 연산 r_convex[r < 1] = r_convex[r < 1]**2 print(r.shape, r_convex[r < 1].shape) ## 오목 렌즈 효과 매핑 좌표 연산 r_concave[r < 1] = r_concave[r < 1]**0.5 ## 렌즈 효과, 직교 좌표 복원 map_convex_x, map_convex_y = cv2.polarToCart(r_convex, theta) map_concave_x, map_concave_y = cv2.polarToCart(r_concave, theta) ## 렌즈 효과, 좌상단 좌표 복원 map_convex_x = ((map_convex_x + 1) * cols) / 2 map_convex_y = ((map_convex_y + 1) * rows) / 2 map_concave_x = ((map_concave_x + 1) * cols) / 2 map_concave_y = ((map_concave_y + 1) * rows) / 2
def Canny_detector(img, weak_th = None, strong_th = None):
# conversion of image to grayscale
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Noise reduction step
img = cv2.GaussianBlur(img, (5, 5), 1.4)
# Calculating the gradients
gx = cv2.Sobel(np.float32(img), cv2.CV_64F, 1, 0, 3)
gy = cv2.Sobel(np.float32(img), cv2.CV_64F, 0, 1, 3)
# Conversion of Cartesian coordinates to polar
mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees = True)
# setting the minimum and maximum thresholds
# for double thresholding
mag_max = np.max(mag)
if not weak_th:weak_th = mag_max * 0.1
if not strong_th:strong_th = mag_max * 0.5
# getting the dimensions of the input image
height, width = img.shape
# Looping through every pixel of the grayscale
# image
for i_x in range(width):
for i_y in range(height):
grad_ang = ang[i_y, i_x]
grad_ang = abs(grad_ang-180) if abs(grad_ang)>180 else abs(grad_ang)
# selecting the neighbours of the target pixel
# according to the gradient direction
# In the x axis direction
if grad_ang<= 22.5:
neighb_1_x, neighb_1_y = i_x-1, i_y
neighb_2_x, neighb_2_y = i_x + 1, i_y
# top right (diagnol-1) direction
elif grad_ang>22.5 and grad_ang<=(22.5 + 45):
neighb_1_x, neighb_1_y = i_x-1, i_y-1
neighb_2_x, neighb_2_y = i_x + 1, i_y + 1
# In y-axis direction
elif grad_ang>(22.5 + 45) and grad_ang<=(22.5 + 90):
neighb_1_x, neighb_1_y = i_x, i_y-1
neighb_2_x, neighb_2_y = i_x, i_y + 1
# top left (diagnol-2) direction
elif grad_ang>(22.5 + 90) and grad_ang<=(22.5 + 135):
neighb_1_x, neighb_1_y = i_x-1, i_y + 1
neighb_2_x, neighb_2_y = i_x + 1, i_y-1
# Now it restarts the cycle
elif grad_ang>(22.5 + 135) and grad_ang<=(22.5 + 180):
neighb_1_x, neighb_1_y = i_x-1, i_y
neighb_2_x, neighb_2_y = i_x + 1, i_y
# Non-maximum suppression step
if width>neighb_1_x>= 0 and height>neighb_1_y>= 0:
if mag[i_y, i_x]<mag[neighb_1_y, neighb_1_x]:
mag[i_y, i_x]= 0
continue
if width>neighb_2_x>= 0 and height>neighb_2_y>= 0:
if mag[i_y, i_x]<mag[neighb_2_y, neighb_2_x]:
mag[i_y, i_x]= 0
weak_ids = np.zeros_like(img)
strong_ids = np.zeros_like(img)
ids = np.zeros_like(img)
cv2.imwrite("temp.jpeg", mag)
# double thresholding step
for i_x in range(width):
for i_y in range(height):
grad_mag = mag[i_y, i_x]
if grad_mag<weak_th:
mag[i_y, i_x]= 0
elif strong_th>grad_mag>= weak_th:
ids[i_y, i_x]= 1
else:
ids[i_y, i_x]= 2
# finally returning the magnitude of
# gradients of edges
return mag
num_rows = int(85 / 5) # 17
a = 0
b = a + 5 * num_rows
xx = x_flow.copy()
xx = reverse_rescale(xx.astype(np.float32), minmax[:, 0], minmax[:, 1])
xx = xx.reshape(85, 2, 224, 224).swapaxes(1, 2).swapaxes(2, 3)
# print(x_flow.shape)
subset = xx[a:b]
fig = plt.figure(figsize=(15, num_rows * 3))
for i, flow in enumerate(subset):
plt.subplot(num_rows, 5, i + 1)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1]) # get magnitude and direction/angle
hsv = np.zeros((flow.shape[0], flow.shape[1], 3), dtype=np.uint8)
hsv[..., 0] = 255 # sets hue
hsv[..., 1] = 255 # # Sets image saturation to maximum
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX) # sets value/brightness
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
im = plt.imshow(255-gray, cmap='gray')
plt.tick_params(
which='both', # both major and minor ticks are affected
bottom=False, # ticks along the bottom edge are off
left=False, # ticks along the top edge are off
labelbottom=False, # labels along the bottom edge are off
labelleft=False
)
def HOG(img, angleBins=8):
# YUV = cv2.cvtColor(img,cv2.COLOR_BGR2YCR_CB)
img = cv2.resize(img, (40, 40))
kernel1 = np.ones((3, 1), np.float32)
kernel2 = np.ones((1, 3), np.float32)
kernel1[2] = -1
kernel1[1] = 0
kernel2[0] = [-1, 0, 1]
# print img
dsth = cv2.filter2D(img, cv2.CV_16S, kernel1).astype(np.float32)
dstv = cv2.filter2D(img, cv2.CV_16S, kernel2).astype(np.float32)
# print dsth
Mag, direction = cv2.cartToPolar(dsth, dstv, angleInDegrees=1)
# print Mag
final = np.zeros((img.shape[0], img.shape[1], 2), np.float32)
for rows in range(len(Mag)):
for cols in range(len(Mag[rows])):
final[rows, cols][0] = max(Mag[rows, cols])
final[rows, cols][1] = direction[rows, cols, Mag[
rows, cols].tolist().index(max(Mag[rows, cols]))]
# print final
Hists = []
for row in final:
histCol = []
for col in row:
hist = [0] * angleBins
index = int(col[1] / (360 / angleBins))
angle = col[1] - index * (360 / angleBins)
try:
i = index % angleBins
except:
i = 0
hist[i] = (angle / (360 / angleBins)) * col[0]
hist[angleBins % (index + 1)] = (1 - (angle /
(360 / angleBins))) * col[0]
histCol.append(hist)
Hists.append(histCol)
histos = np.array(Hists).astype(np.float32)
# print histos
# histos = np.swapaxes(hists,0,2)
# print hists
# print histos
kernel = np.ones((5, 5), np.float32)
histos = cv2.filter2D(histos, cv2.CV_32FC1, kernel).astype(np.float32)
histos = histos[::5, ::5, :]
final = []
for x in range(len(histos) - 1):
row = []
for y in range(len(histos[0]) - 1):
lister = []
lister.extend(histos[x, y])
lister.extend(histos[x + 1, y])
lister.extend(histos[x, y + 1])
lister.extend(histos[x + 1, y + 1])
row.append(lister)
final.append(row)
# print histos
# final = np.array(final)
# print final
# print final.shape
histos = [L2HysNormalize(x) for row in final for x in row]
histos = [x for row in histos for x in row]
# print histos
# print np.array(histos).shape
return histos
# extract the image filename (assumed to be unique)
filename = imagePath[imagePath.rfind("/") + 1:]
# Read the image as grey image
image = cv2.imread(imagePath, 0)
# Use canny edge detector to select edge points
cannyImageMask = cv2.Canny(image, 100, 250)
# To create the 8-bit mask
cannyImageMask = np.uint8(cannyImageMask)
# Apply bitwise and on the image to mask it
maskedImage = cv2.bitwise_and(image, image, mask=cannyImageMask)
# Compute gradients in x and y direction
sobelXDir = cv2.Sobel(maskedImage, cv2.CV_64F, 1, 0, ksize=5)
sobelYDir = cv2.Sobel(maskedImage, cv2.CV_64F, 0, 1, ksize=5)
# Compute magnitude and theta angle using the gradients
magnitude, theta = cv2.cartToPolar(sobelXDir,
sobelYDir,
angleInDegrees=True)
# To turn theta into hist index
theta = np.round(np.divide(theta, 10))
theta = np.uint8(theta)
# flatten the theta and magnitude arrays
flattenedTheta = hist_bins(theta)
flattenedMagnitude = hist_bins(magnitude)
# Build 36-bin histograms
hist, bins = np.histogram(flattenedTheta,
range(37),
weights=flattenedMagnitude)
histogram_grey_list[filename] = hist
plt.plot(hist)
plt.show()
def main():
# uncomment only one
#
logging.basicConfig(format='%(message)s', level=logging.INFO)
#logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
# load camera configuration
try:
settings = config.camera
except AttributeError:
settings = {}
# send counters to Unix Domain Socket
import uds
# use Raspberry Pi Camera
#
camera = PiCamera()
camera.resolution = (320, 240)
rawCapture = PiRGBArray(camera, size=(320, 240))
time.sleep(0.1)
camera.capture(rawCapture, format="bgr")
image = rawCapture.array
prev = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
np.zeros_like(prev)
rawCapture.truncate(0)
# initialise model for human faces
#
face_cascade = cv2.CascadeClassifier('models/haarcascade_frontalface_alt.xml')
# initialise model for standing humans
#
hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
# compute counters every 2 seconds
#
flagone = datetime.datetime.now()
while True:
flagtwo = datetime.datetime.now()
elapsed = (flagtwo - flagone).total_seconds()
if elapsed < 2:
time.sleep(0.1)
continue
flagone = datetime.datetime.now()
people_count = 0
people_moves = 0
people_faces = 0
# capture an image
#
mask = np.zeros(image.shape[:2], dtype='uint8')
camera.capture(rawCapture, format='bgr')
image = rawCapture.array
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rawCapture.truncate(0)
# detect human faces
#
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
people_faces = len(faces)
# detect human beings
#
(rects, _) = hog.detectMultiScale(image,
winStride=(4, 4),
padding=(8, 8),
scale=1.07)
rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
pick = non_max_suppression(rects, probs=None, overlapThresh=0.65)
people_count = len(pick)
for(xA, yA, xB, yB) in pick:
cv2.rectangle(mask, (xA, yA), (xB, yB), 255, -1)
# count moving people
#
nextim = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
nextim = cv2.bitwise_and(nextim, nextim, mask=mask)
flow = cv2.calcOpticalFlowFarneback(prev, nextim, None, 0.5, 1, 3, 15, 3, 5, 1)
mag, _ = cv2.cartToPolar(flow[..., 0], flow[..., 1])
mag = mag * 0.8
prev = nextim
for(xA, yA, xB, yB) in pick:
try:
m = np.median(mag[yA:yB, xA:xB])
# print m
if m > 1.6:
people_moves += 1
except RuntimeWarning:
pass
# push counters via Unix Domain Socket
#
message = '%s %d %d %d' % (settings.get('id', 'myCamera'),
people_count,
people_moves,
people_faces)
uds.push(message)
starttime = time.time()
dualtvl1_opticalflow = cv2.optflow.DualTVL1OpticalFlow_create()
#
# @jit
# flowDTVL1=dualtvl1_opticalflow.calc(prvs,nextframe,None)
flowDTVL1 = dualtvl1_opticalflow.calc(prvs, nextframe, None)
# help(dualtvl1_opticalflow.calc)
# print(prvs.dtype,nextframe.dtype)
# flowDTVL1=calc_optical(prvs,nextframe,None)
print(flowDTVL1.dtype)
# flowDTVL1=cv2.calcOpticalFlowFarneback(prvs,nextframe,None,0.5,3,15,3,5,1.2,0)endtime=time.time()
endtime = time.time()
#print(flowDTVL1.shape)
mag, ang = cv2.cartToPolar(flowDTVL1[..., 0], flowDTVL1[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
# endtime=time.time()
fps = 1 / (endtime - starttime) #计算帧率
print("fps is", fps)
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('opticalflow image', rgb)
cv2.imshow('original image', frame1)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
elif k == ord('s'):
cv2.imwrite('opt', frame1)
cv2.imwrite('rgb', rgb)
import cv2 as cv
import numpy as np
cap = cv.VideoCapture("videos/test.mp4")
ret, frame1 = cap.read()
prvs = cv.cvtColor(frame1, cv.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
while (1):
ret, frame2 = cap.read()
next = cv.cvtColor(frame2, cv.COLOR_BGR2GRAY)
flow = cv.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2,
0)
mag, ang = cv.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv.normalize(mag, None, 0, 255, cv.NORM_MINMAX)
bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
cv.imshow('frame2', bgr)
k = cv.waitKey(30) & 0xff
if k == 27:
break
elif k == ord('s'):
cv.imwrite('opticalfb.png', frame2)
cv.imwrite('opticalhsv.png', bgr)
prvs = next
cap.release()
cv.destroyAllWindows()
def preprocess_video(data_id):
print('preprocessing data: {0} ...'.format(data_id))
label_path = os.path.join(label_dir, data_id + '.txt')
video_path = os.path.join(video_dir, data_id + '.avi')
video_capture = cv2.VideoCapture(video_path)
_, frame = video_capture.read()
frame_id = 1
num_actions, action_classes, start_frames, end_frames = parse_label(
label_path)
for i in range(num_actions):
cur_action_class = action_classes[i]
print(' No.{:02} action, belongs to class {:02}'.format(
i + 1, cur_action_class))
cur_rgb_dir = os.path.join(rgb_frame_dir,
'{:02}'.format(cur_action_class))
cur_optical_flow_dir = os.path.join(optical_flow_dir,
'{:02}'.format(cur_action_class))
if not os.path.exists(cur_rgb_dir):
os.mkdir(cur_rgb_dir)
if not os.path.exists(cur_optical_flow_dir):
os.mkdir(cur_optical_flow_dir)
start_frame, end_frame = start_frames[i], end_frames[i]
frame_interval = round((end_frame - start_frame) / NUM_FRAME_SAMPLE)
frame_interval = max(frame_interval, 1)
frame_count = 0
# optical flow frame
prvs = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame)
hsv[..., 1] = 255
while frame_id < start_frame:
_, frame = video_capture.read()
frame_id += 1
while frame_id < end_frame:
if frame_id % frame_interval == 0:
frame_count += 1
# rgb frame
frame_filename = data_id + '-{:02}.jpg'.format(frame_count)
frame_file_path = os.path.join(cur_rgb_dir, frame_filename)
cv2.imwrite(frame_file_path, frame)
# optical flow frame
# reference: https://docs.opencv.org/3.3.1/d7/d8b/tutorial_py_lucas_kanade.html
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prvs, gray, None, 0.5, 3,
15, 3, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
optical_flow_frame = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
optical_flow_filename = data_id + '-flow-{:02}.jpg'.format(
frame_count)
optical_flow_file_path = os.path.join(cur_optical_flow_dir,
optical_flow_filename)
cv2.imwrite(optical_flow_file_path, optical_flow_frame)
prvs = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame_id += 1
_, frame = video_capture.read()
def to_polar(x, y):
mag, ang = cv2.cartToPolar(x, y)
return mag, ang
def compute_optical_flow(m,
mask=None,
polar_coord=True,
do_show=False,
do_write=False,
file_name=None,
gain_of=None,
frate=30,
pyr_scale=.1,
levels=3,
winsize=25,
iterations=3,
poly_n=7,
poly_sigma=1.5):
"""
This function compute the optical flow of behavioral movies using the opencv cv2.calcOpticalFlowFarneback function
Parameters:
----------
m: 3D ndarray:
input movie
mask: 2D ndarray
mask selecting relevant pixels
polar_coord: boolean
wheather to return the coordinate in polar coordinates (or cartesian)
do_show: bool
show flow movie
do_write: bool
save flow movie
frate: double
frame rate saved movie
parameters_opencv_function: cv2.calcOpticalFlowFarneback
pyr_scale,levels,winsize,iterations,poly_n,poly_sigma
Returns:
--------
mov_tot: 4D ndarray containing the movies of the two coordinates
Raise:
-----
Exception('You need to provide file name (.avi) when saving video')
"""
prvs = np.uint8(m[0])
frame1 = cv2.cvtColor(prvs, cv2.COLOR_GRAY2RGB)
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
if do_show:
cv2.namedWindow("frame2", cv2.WINDOW_NORMAL)
if mask is not None:
data = mask.astype(np.int32)
else:
data = 1
T, d1, d2 = m.shape
mov_tot = np.zeros([2, T, d1, d2])
if do_write:
if file_name is not None:
video = cv2.VideoWriter(file_name,
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'),
frate, (d2 * 2, d1), 1)
else:
raise Exception(
'You need to provide file name (.avi) when saving video')
for counter, next_ in enumerate(m):
if counter % 100 == 0:
print(counter)
frame2 = cv2.cvtColor(np.uint8(next_), cv2.COLOR_GRAY2RGB)
flow = cv2.calcOpticalFlowFarneback(prvs, next_, None, pyr_scale,
levels, winsize, iterations,
poly_n, poly_sigma, 0)
if polar_coord:
coord_1, coord_2 = cv2.cartToPolar(flow[..., 0], flow[..., 1])
else:
coord_1, coord_2 = flow[:, :, 0], flow[:, :, 1]
coord_1 *= data
coord_2 *= data
if do_show or do_write:
if polar_coord:
hsv[..., 0] = coord_2 * 180 / np.pi / 2
else:
hsv[..., 0] = cv2.normalize(coord_2, None, 0, 255,
cv2.NORM_MINMAX)
if gain_of is None:
hsv[..., 2] = cv2.normalize(coord_1, None, 0, 255,
cv2.NORM_MINMAX)
else:
hsv[..., 2] = gain_of * coord_1
rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
frame_tot = np.concatenate([rgb, frame2], axis=1)
if do_write:
video.write(frame_tot)
if do_show:
cv2.imshow('frame2', frame_tot)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
mov_tot[0, counter] = coord_1
mov_tot[1, counter] = coord_2
prvs = next_.copy()
if do_write:
video.release()
if do_show:
cv2.destroyAllWindows()
return mov_tot
def opt_flow(cap, show_video, filename):
# buffer size for keeping RAM smooth
maxlen = 1000
mag_deque = deque(maxlen=maxlen)
timestamp_deque = deque(maxlen=maxlen)
xy_deque = deque(maxlen=maxlen)
# grab the current frame
frame1 = cap.read()
# images will come as
# (h, w, channels)
original_width = frame1.shape[1]
# resize_width for ease of computation
resize_width = 320
# reduce size
frame1 = imutils.resize(frame1, width=resize_width)
# ret, frame1 = cap.read()
# Grayscale
prev = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
# We fix saturation into the maximal possible value
hsv[..., 1] = 255
# create_iteration number
iter_number = 0
while (True):
# get timestamp
timestamp = datetime.datetime.now().isoformat(" ")
timestamp_deque.append(timestamp)
frame2 = cap.read()
# if we are viewing a video and we did not grab a frame,
# then we have reached the end of the video
if frame2 is None:
print("End of video. Getting out")
break
# reduce the frame so that we speed up computation
frame2 = imutils.resize(frame2, width=resize_width)
gray = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (5, 5), 0)
# see docs here: https://docs.opencv.org/2.4/modules/video/doc/motion_analysis_and_object_tracking.html
flow = cv2.calcOpticalFlowFarneback(
prev,
gray,
None,
pyr_scale=0.5,
levels=3,
winsize=
20, # averaging window size; larger values increase the algorithm robustness to image noise and give more chances for fast motion detection, but yield more blurred motion field.
iterations=3,
poly_n=5, # typically poly_n =5 or 7.
poly_sigma=1.1, # 1.1 for poly_n = 5 and 1.5 for poly_n = 7
flags=0)
# For OpenCV’s implementation, it computes the magnitude and direction
# of optical flow from a 2-channel array of flow vectors (dx/dt,dy/dt),
# the optical flow problem.
# It then visualizes the angle (direction) of flow by hue and the distance (magnitude)
# of flow by value of HSV color representation.
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
# Increase signal to noise ratio ?
# We can always do this afterwards but visual normalization might need it
#mag = mag * mag
# np.median is probably less noisy but it misses a lot of movement
sum_mag = np.sum(mag)
mag_deque.append(sum_mag)
# if there's enough movement
if sum_mag > 1000:
# if mag is 1 for any pixel looks like real movement
# try to calculate mask and centroid
# calculate the mask as cv2 likes it
mask = np.array((mag > 1) * 255).astype('uint8')
xy = get_centroid(mask)
# xy will be a tupple
# we need to adjust with resize factor
# the way to keep it tupple is with tuple and list comprehension
if xy is not None:
xy = tuple([
int(value * original_width / resize_width) for value in xy
])
xy_deque.append(xy)
else:
xy_deque.append(None)
mask = None
if (show_video):
# Direction/angle goes into hue (first channel)
hsv[..., 0] = ang * 180 / np.pi / 2
# magnitude goes into value (third channel)
# We normalize to be able to see...
# Because this distorts values, all data analysis will use the mag object
hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
#bgr_blur = cv2.medianBlur(bgr, 5)
#bgr_blur[bgr_blur < 50] = 0
# put text for the total movement
cv2.putText(bgr, "total mov: " + str(round(sum_mag, 2)), (10, 20),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1)
cv2.imshow('frame2', bgr)
cv2.imshow('original', gray)
#cv2.imshow('blurr', bgr_blur)
if mask is not None:
show_mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
if xy is not None:
# we need to correct back for the resizing to show
xy_show = tuple([
int(value * resize_width / original_width)
for value in xy
])
cv2.circle(
show_mask,
xy_show,
5, # a very small circle
(0, 0, 255), # red
-1
) # Negative thickness means that a filled circle is to be drawn.
cv2.imshow('mask', show_mask)
k = cv2.waitKey(1) & 0xff
if k == 27:
break
# possiblilty to save via command
#elif k == ord('s'):
# with open('mag_deque.csv','a') as outfile:
# np.savetxt(outfile, mag_deque,
# delimiter=',', fmt='%s')
else:
# if we don't give any feedback it's difficult to know
print('opt_flow.py Iteration: {} Total movement: {}'.format(
iter_number, sum_mag),
end="\r")
# Clean-up
# assign the last frame to previous
prev = gray
unsaved_elements = iter_number % maxlen
if (unsaved_elements == 0):
save_deque(iter_number, timestamp_deque, mag_deque, xy_deque,
maxlen, filename)
iter_number = iter_number + 1
exit_handler(iter_number, timestamp_deque, mag_deque, xy_deque, maxlen,
filename)
return mag_deque