def dense_flow(augs):
'''
To extract dense_flow images
:param augs:the detailed augments:
video_name: the video name which is like: 'v_xxxxxxx',if different ,please have a modify.
save_dir: the destination path's final direction name.
step: num of frames between each two extracted frames
bound: bi-bound parameter
:return: no returns
'''
video_name, save_dir, step, bound = augs
video_path = str(video_name)
print(video_name)
cap_iter = cap_vid(video_path, save_dir, skip=6, init_frame=3)
dtvl1 = cv2.createOptFlow_DualTVL1()
for prev_image, next_frame, frame_num in cap_iter:
if not dtvl1.getUseInitialFlow():
flowDTVL1 = dtvl1.calc(prev_image, next_frame, None)
dtvl1.setUseInitialFlow(True)
else:
flowDTVL1 = dtvl1.calc(prev_image, next_frame, flowDTVL1)
# # # this is to save flows and img.
save_flows(flowDTVL1.copy(), next_frame, save_dir, frame_num, bound)
#cv2.destroyAllWindows()
print(f'{video_path} captured')
def cal_optical_cv2(augs):
dir_name, bound = augs
dir_name = dir_name.split(' ')[0]
parent, dirnames, imagenames = next(os.walk(dir_name))
imagenames = sorted(imagenames)
for i in range(len(imagenames)-1): # there is no flow for the last image
s = time.time()
image_path = os.path.join(parent, imagenames[i])
frame_0 = cv2.imread(image_path,cv2.IMREAD_GRAYSCALE)
image_path = os.path.join(parent, imagenames[i+1])
frame_1 = cv2.imread(image_path,cv2.IMREAD_GRAYSCALE)
dtvl1=cv2.createOptFlow_DualTVL1()
flowDTVL1=dtvl1.calc(frame_0,frame_1,None)
e = time.time()
print(e-s)
u = flowDTVL1[:,:,0]
v = flowDTVL1[:,:,1]
mag = np.sqrt(u**2+v**2)
u, v = [ToImg(i,bound) for i in [u, v]]
mag = ToImg(mag, (0, bound*1.414))
flow = np.stack((u, v, mag), axis=2)
# flow = v
save_path = dir_name.replace('UCF-101', 'UCF-101-optical-flow')
save_name = os.path.join(save_path, '{:04d}.jpg'.format(i))
print(save_name)
if not os.path.exists(save_path):
os.makedirs(save_path)
else:
cv2.imwrite(save_name, flow)
def DenseOpticalFlows():
print("Dense Optical Flow Demo ")
img1 = cv2.imread("D:/OpenCv4Programmers/datas/frm1.png")
img2 = cv2.imread("D:/OpenCv4Programmers/datas/frm2.png")
cv2.imshow("Img1", img1)
cv2.imshow("Img2", img2)
cv2.waitKey(10)
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
# Farneback
start = cv2.getTickCount()
flowFarneback = cv2.calcOpticalFlowFarneback(img1, img2, None, 0.25, 3, 15,
5, 5, 1.2, 0)
timeSec = (cv2.getTickCount() - start) / cv2.getTickFrequency()
print(" Farnback Optical flow time ", timeSec, " sec")
# DualTVL1
start = cv2.getTickCount()
tvl1 = cv2.createOptFlow_DualTVL1()
flowDualTVL1 = tvl1.calc(img1, img2, None)
timeSec = (cv2.getTickCount() - start) / cv2.getTickFrequency()
print(" DualTVL1 Optical flow time ", timeSec, " sec")
outImgFarneback = drawFlow(flowFarneback, img2)
outImgDualTVL1 = drawFlow(flowDualTVL1, img2)
cv2.imshow("Farneback Optical Flow ", outImgFarneback)
cv2.imshow("DualTVL1 Optical Flow ", outImgDualTVL1)
cv2.waitKey(0)
cv2.destroyAllWindows()
def test_cv2_flann():
"""
Ignore:
[name for name in dir(cv2) if 'create' in name.lower()]
[name for name in dir(cv2) if 'stereo' in name.lower()]
ut.grab_zipped_url('https://priithon.googlecode.com/archive/a6117f5e81ec00abcfb037f0f9da2937bb2ea47f.tar.gz', download_dir='.')
"""
import cv2
from vtool.tests import dummy
import plottool as pt
import vtool as vt
img1 = vt.imread(ut.grab_test_imgpath('easy1.png'))
img2 = vt.imread(ut.grab_test_imgpath('easy2.png'))
stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15)
disparity = stereo.compute(img1, img2)
pt.imshow(disparity)
pt.show()
#cv2.estima
flow = cv2.createOptFlow_DualTVL1()
img1, img2 = vt.convert_image_list_colorspace([img1, img2], 'gray', src_colorspace='bgr')
img2 = vt.resize(img2, img1.shape[0:2][::-1])
out = img1.copy()
flow.calc(img1, img2, out)
orb = cv2.ORB_create()
kp1, vecs1 = orb.detectAndCompute(img1, None)
kp2, vecs2 = orb.detectAndCompute(img2, None)
detector = cv2.FeatureDetector_create("SIFT")
descriptor = cv2.DescriptorExtractor_create("SIFT")
skp = detector.detect(img1)
skp, sd = descriptor.compute(img1, skp)
tkp = detector.detect(img2)
tkp, td = descriptor.compute(img2, tkp)
out = img1.copy()
cv2.drawKeypoints(img1, kp1, outImage=out)
pt.imshow(out)
vecs1 = dummy.testdata_dummy_sift(10)
vecs2 = dummy.testdata_dummy_sift(10) # NOQA
FLANN_INDEX_KDTREE = 0 # bug: flann enums are missing
#flann_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=4)
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params) # NOQA
cv2.flann.Index(vecs1, index_params)
#cv2.FlannBasedMatcher(flann_params)
cv2.flann.Index(vecs1, flann_params) # NOQA
def main(args=None, parser=None):
data_dir = '/home/ye/Works/diving/frames'
flow_dir = '/home/ye/Works/diving/flow'
folder = flow_dir
file_dir = data_dir
video_files = os.listdir(file_dir)
# print video_files
nVideos = len(video_files)
start_time = time.time()
for i in range(0, nVideos):
print i, '/', nVideos
vid_file = video_files[i]
bn = os.path.basename(vid_file)
prefix = os.path.splitext(bn)[0]
print prefix
imgae_folder = join(folder, prefix)
vid_file = join(data_dir, vid_file)
print vid_file
if vid_file != '/home/ye/Works/diving/frames/._.DS_Store' and vid_file != '/home/ye/Works/diving/frames/.DS_Store':
img_list = collect_files(vid_file,
file_ext=".jpg",
sort_files=True)
for i in range(len(img_list) - 1):
img_0 = cv2.imread(join(vid_file, img_list[i]))
img_1 = cv2.imread(join(vid_file, img_list[i + 1]))
frame_0 = cv2.cvtColor(img_0, cv2.COLOR_RGB2GRAY)
frame_1 = cv2.cvtColor(img_1, cv2.COLOR_RGB2GRAY)
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
flow_x = ToImg(flowDTVL1[..., 0], 20)
flow_y = ToImg(flowDTVL1[..., 1], 20)
if not os.path.exists(imgae_folder):
os.makedirs(imgae_folder)
save_x = os.path.join(imgae_folder,
'flow_x_{:05d}.jpg'.format(i))
save_y = os.path.join(imgae_folder,
'flow_y_{:05d}.jpg'.format(i))
cv2.imwrite(save_x, flow_x)
cv2.imwrite(save_y, flow_y)
print '\nDONE\n'
elapsed_time = time.time() - start_time
print 'time: ', elapsed_time
return 0
def find_differences_cc(healthy, impaired, enhanced, Th=0.25, scale=20):
optical_flow = cv2.createOptFlow_DualTVL1()
scale1 = 0.5
# RGB DIFFERENCE
t = time()
difference = compute_difference(impaired, enhanced, kernel=5)
#print('Difference in %.2f'%(time()-t))
difference[0:difference.shape[0] // 6] = 0
difference[-difference.shape[0] // 8:] = 0
difference[:, 0:difference.shape[1] // 6] = 0
difference[:, -difference.shape[1] // 6:] = 0
t = time()
diff_image = difference2color(difference, impaired,
Th).astype('float32') / 255
#print('DiffImage in %.2f'%(time()-t))
# FLOW
t = time()
impaired, enhanced = resize(impaired, scale1), resize(enhanced, scale1)
impaired_gray = cv2.cvtColor(impaired, cv2.COLOR_RGB2GRAY)
enhanced_gray = cv2.cvtColor(enhanced, cv2.COLOR_RGB2GRAY)
flow = optical_flow.calc(impaired_gray, enhanced_gray,
None) # compute flow
#print('Flow in %.2f'%(time()-t))
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
flow = flow / np.repeat(mag[:, :, np.newaxis], 2, axis=2)
# MASK
t = time()
mask = difference >= Th
#mask = np.logical_and(mask,mag>1.0)
mask = dilation(mask, disk(6))
mask = erosion(mask, disk(3))
#print('Mask in %.2f'%(time()-t))
t = time()
mask_labels = measure.label(mask, background=0)
labels = np.unique(mask_labels)
flow_sparse, areas = [], []
for l in range(1, labels.max() + 1):
m = np.where(mask_labels == l)
#print(len(m[0]))
if len(m[0]) < 150: continue
m = [(m[0] * scale1).astype(int), (m[1] * scale1).astype(int)]
fx, fy = flow[m[0], m[1], 0].max(), flow[m[0], m[1], 1].max()
x, y = int(np.median(m[0]) / scale1), int(np.median(m[1]) / scale1)
flow_sparse.append([x, y, fx, fy])
areas.append(len(m[0]))
#print('CC in %.2f'%(time()-t))
#diff_image = mask_labels
diff_image = resize(diff_image, 1 / scale1)
#print diff_image.dtype
if len(flow_sparse) == 0:
return diff_image, np.zeros([1, 2]), [0], [0], np.zeros(1)
flow_sparse = np.array(flow_sparse)
return diff_image, flow_sparse[:, 2:], flow_sparse[:, 1].astype(
int), flow_sparse[:, 0].astype(int), np.array(areas)
def get_optical_flow_function(high_quality=False):
opt_flow = cv2.createOptFlow_DualTVL1()
opt_flow.setUseInitialFlow(True)
if not high_quality:
# see https://stackoverflow.com/questions/19309567/speeding-up-optical-flow-createoptflow-dualtvl1
opt_flow.setTau(1 / 4)
opt_flow.setScalesNumber(3)
opt_flow.setWarpingsNumber(3)
opt_flow.setScaleStep(0.5)
return opt_flow
def set_optical_flow_function(self):
if self.opt_flow:
return
self.opt_flow = cv2.createOptFlow_DualTVL1()
self.opt_flow.setUseInitialFlow(True)
if not self.config.high_quality_optical_flow:
# see https://stackoverflow.com/questions/19309567/speeding-up-optical-flow-createoptflow-dualtvl1
self.opt_flow.setTau(1 / 4)
self.opt_flow.setScalesNumber(3)
self.opt_flow.setWarpingsNumber(3)
self.opt_flow.setScaleStep(0.5)
def python_extractor(op_method, videocapture, name, params):
if videocapture.sum() == 0:
print 'could not initialize capturing {}'.format()
exit()
if op_method == 'tvl1':
calc_method = cv.createOptFlow_DualTVL1()
else: #op_method=='fb'
calc_method = cv.calcOpticalFlowFarneback
out_frames_path = os.path.join(out_path, name)
len_frame = len(videocapture)
frame_num = 0
image, prev_image, gray, prev_gray = None, None, None, None
num0 = 0
while True:
if num0 >= len_frame:
break
frame = videocapture[num0]
num0 += 1
if frame_num == 0:
image = np.zeros_like(frame)
gray = np.zeros_like(frame)
prev_gray = np.zeros_like(frame)
prev_image = frame
prev_gray = cv.cvtColor(prev_image, cv.COLOR_BGR2GRAY)
frame_num += 1
step_t = params['step']
while step_t > 1:
num0 += 1
step_t -= 1
continue
image = frame
gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
frame_0 = prev_gray
frame_1 = gray
if op_method == 'tvl1':
OutFlow = calc_method.calc(frame_0, frame_1, None)
else:
OutFlow = calc_method(frame_0, frame_1, None, 0.6, 3, 25, 7, 5,
1.2, cv.OPTFLOW_FARNEBACK_GAUSSIAN)
save_flows(OutFlow, image, out_frames_path, frame_num, params['bound'])
prev_gray = gray
prev_image = image
frame_num += 1
step_t = params['step']
while step_t > 1:
num0 += 1
step_t -= 1
def find_differences(healthy, impaired, enhanced, Th=0.25, scale=20):
scale1, scale2 = 1.0, scale
optical_flow = cv2.createOptFlow_DualTVL1()
#optical_flow = cv2.DualTVL1OpticalFlow_create()
# RGB DIFFERENCE
difference = compute_difference(impaired, enhanced, kernel=5)
#difference[0:difference.shape[0]/5] = 0
#difference[difference.shape[0]/8:] = 0
#difference[:,0:difference.shape[1]/5] = 0
#difference[:,difference.shape[1]/5:] = 0
diff_image = difference2color(difference, impaired, Th)
# FLOW
impaired_small = (resize(impaired, scale1) * 255).astype(
'uint8') # resize for reducing flow resolution
enhanced_small = (resize(enhanced, scale1) * 255).astype('uint8')
diff_rescale = np.linspace(0, difference.shape[0] - 1,
int(scale1 * difference.shape[0])).astype(int)
difference_small = difference[diff_rescale,
diff_rescale] #resize(difference,scale1)
impaired_gray = cv2.cvtColor(impaired_small, cv2.COLOR_RGB2GRAY)
enhanced_gray = cv2.cvtColor(enhanced_small, cv2.COLOR_RGB2GRAY)
flow = optical_flow.calc(enhanced_gray, impaired_gray,
None) # compute flow
# FLOW VECTOR TO IMAGE
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
flow = flow / np.repeat(mag[:, :, np.newaxis], 2, axis=2)
mask = np.logical_and(difference_small >= Th, mag > 2)
flow_filter = np.stack([flow[:, :, 0] * mask, flow[:, :, 1] * mask],
axis=2)
flow_filter_sparse = np.zeros([
int(flow_filter.shape[0] / scale1),
int(flow_filter.shape[1] / scale1), flow_filter.shape[2]
], flow_filter.dtype)
for x in range(0, flow_filter.shape[0] - scale2 // 2, scale2):
for y in range(0, flow_filter.shape[1] - scale2 // 2, scale2):
X, Y = int((x + scale2 / 2) / scale1), int(
(y + scale2 / 2) / scale1)
m = flow_filter[x:x + scale2, y:y + scale2].reshape([-1, 2])
mx, my = m[:, 0], m[:, 1]
#m = np.stack([mx[mx!=0].mean(0),my[my!=0].mean(0)])
m = np.stack([mx.max(), my.max()])
flow_filter_sparse[X, Y] = m if not np.isnan(m).any() else 0
mag, ang = cv2.cartToPolar(flow_filter_sparse[..., 0],
flow_filter_sparse[..., 1])
flow_filter_sparse = flow_filter_sparse / (
np.repeat(mag[:, :, np.newaxis], 2, axis=2) + 0.01)
#flow_filter_sparse = np.stack([resize(flow_filter[:,:,0],1/scale1),resize(flow_filter[:,:,1],1/scale1)],2)
X, Y = np.where(
np.logical_or(flow_filter_sparse[:, :, 0] != 0,
flow_filter_sparse[:, :, 1] != 0))
return diff_image, flow_filter_sparse, X, Y
def compute_TVL1(prev, curr, bound=15):
"""Compute the TV-L1 optical flow."""
#TVL1 = cv2.DualTVL1OpticalFlow_create()
# TVL1 = cv2.DualTVL1OpticalFlow_create()
TVL1 = cv2.createOptFlow_DualTVL1()
flow = TVL1.calc(prev, curr, None)
assert flow.dtype == np.float32
flow = (flow + bound) * (255.0 / (2 * bound))
flow = np.round(flow).astype(int)
flow[flow >= 255] = 255
flow[flow <= 0] = 0
return flow
def get_optflow_retval(algorithm):
if algorithm.lower() == 'deepflow':
retval = cv2.optflow.createOptFlow_DeepFlow()
elif algorithm.lower() == 'farneback':
retval = cv2.optflow.createOptFlow_Farneback()
elif algorithm.lower() == 'tvl1':
retval = cv2.createOptFlow_DualTVL1()
elif algorithm.lower() == 'sparse2dense':
retval = cv2.optflow.createOptFlow_SparseToDense()
elif algorithm == 'DISflow_ultrafast':
retval = cv2.optflow.createOptFlow_DIS(0)
elif algorithm == 'DISflow_fast':
retval = cv2.optflow.createOptFlow_DIS(1)
elif algorithm == 'DISflow_medium':
retval = cv2.optflow.createOptFlow_DIS(2)
else: raise ValueError('algorithm is not found : {:}'.format( algorithm ))
return retval
def __init__(self, model):
self.model = model
# create a reduced quality optical flow.
self.opt_flow = cv2.createOptFlow_DualTVL1()
self.opt_flow.setTau(1 / 4)
self.opt_flow.setScalesNumber(3)
self.opt_flow.setWarpingsNumber(3)
self.opt_flow.setScaleStep(0.5)
self.opt_flow.setUseInitialFlow(True)
self.prev = None
self.thermal = None
self.filtered = None
self.flow = None
self.mask = None
def tvl1_simple(img1, img2, imtype="none", Lambda=0.9, **kwargs):
# gray1 = get_gray(img1,imtype)
# gray2 = get_gray(img2,imtype)
tvl1 = cv2.createOptFlow_DualTVL1()
# opflow = np.zeros_like(gray1)
tvl1.setLambda(Lambda)
print("Running...", img1.shape)
img1 = np.array(img1, dtype=np.float32)
img2 = np.array(img2, dtype=np.float32)
opflow = tvl1.calc(img1, img2, None)
# rgb = of2rgb(opflow[:,:,0],opflow[:,:,1])
# imgi = warp_flow(img1, opflow, 2.0)
# return imgi, rgb
return opflow[:, :, 0], opflow[:, :, 1], np.nan
def dense_flow(augs):
'''
To extract dense_flow images
:param augs:the detailed augments:
video_name: the video name which is like: 'v_xxxxxxx',if different ,please have a modify.
save_dir: the destination path's final direction name.
step: num of frames between each two extracted frames
bound: bi-bound parameter
:return: no returns
'''
video_name, save_dir, step, bound = augs
#video_name=video_name.split('/')[-1]
if not os.path.exists(video_name):
print 'Could not find image folder! ', video_name
exit()
image, prev_image, gray, prev_gray = None, None, None, None
flow_num = 0
imagelist = os.listdir(video_name)
for element in range(1, len(imagelist) + 1, step):
if flow_num == 0:
image_path = os.path.join(video_name, "%03d.jpg" % (element))
prev_image = cv2.imread(image_path)
prev_gray = cv2.cvtColor(prev_image, cv2.COLOR_RGB2GRAY)
flow_num += 1
continue
image_path = os.path.join(video_name, "%03d.jpg" % (element))
current_image = cv2.imread(image_path)
img1 = prev_image[100, 100]
img2 = current_image[100, 100]
current_gray = cv2.cvtColor(current_image, cv2.COLOR_RGB2GRAY)
frame_0 = prev_gray
frame_1 = current_gray
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
save_flows(flowDTVL1, save_dir, flow_num,
bound) #this is to save flows and img.
prev_gray = current_gray
prev_image = current_image
flow_num += 1
def dense_flow(augs):
'''
To extract dense_flow images
:param augs:the detailed augments:
video_name: the video name which is like: 'v_xxxxxxx',if different ,please have a modify.
save_dir: the destination path's final direction name.
step: num of frames between each two extracted frames
bound: bi-bound parameter
:return: no returns
'''
video_name, save_dir, step, bound = augs
video_path = os.path.join(videos_root,
video_name.split('_')[1], video_name)
# provide two video-read methods: cv2.VideoCapture() and skvideo.io.vread(), both of which need ffmpeg support
# videocapture=cv2.VideoCapture(video_path)
# if not videocapture.isOpened():
# print 'Could not initialize capturing! ', video_name
# exit()
try:
videocapture = skvideo.io.vread(video_path)
except:
print '{} read error! '.format(video_name)
return 0
print video_name
# if extract nothing, exit!
if videocapture.sum() == 0:
print 'Could not initialize capturing', video_name
exit()
len_frame = len(videocapture)
frame_num = 0
image, prev_image, gray, prev_gray = None, None, None, None
num0 = 0
while True:
#frame=videocapture.read()
if num0 >= len_frame:
break
frame = videocapture[num0]
num0 += 1
if frame_num == 0:
image = np.zeros_like(frame)
gray = np.zeros_like(frame)
prev_gray = np.zeros_like(frame)
prev_image = frame
prev_gray = cv2.cvtColor(prev_image, cv2.COLOR_BGR2GRAY)
frame_num += 1
# to pass the out of stepped frames
step_t = step
while step_t > 1:
#frame=videocapture.read()
num0 += 1
step_t -= 1
continue
image = frame
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
frame_0 = prev_gray
frame_1 = gray
##default choose the tvl1 algorithm
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
save_flows(flowDTVL1, image, save_dir, frame_num,
bound) #this is to save flows and img.
prev_gray = gray
prev_image = image
frame_num += 1
# to pass the out of stepped frames
step_t = step
while step_t > 1:
#frame=videocapture.read()
num0 += 1
step_t -= 1
def extract_tracks(self):
"""
Extracts tracks from given source. Setting self.tracks to a list of good tracks within the clip
:param source_file: filename of cptv file to process
:returns: True if clip was successfully processed, false otherwise
"""
assert self.frame_buffer.thermal, "Must call load before extract tracks"
frames = self.frame_buffer.thermal
self.reject_reason = None
# for now just always calculate as we are using the stats...
background, background_stats = self.process_background(frames)
if self.config.background_calc == self.PREVIEW:
if self.preview_secs > 0:
self.background_is_preview = True
background = self.calculate_preview(frames)
else:
logging.info("No preview secs defined for CPTV file - using statistical background measurement")
if len(frames) <= 9:
self.reject_reason = "Clip too short {} frames".format(len(frames))
return False
if self.reject_non_static_clips and not self.stats['is_static']:
self.reject_reason = "Non static background deviation={:.1f}".format(
background_stats.background_deviation)
return False
# don't process clips that are too hot.
if self.config.max_mean_temperature_threshold and background_stats.mean_temp > self.config.max_mean_temperature_threshold:
self.reject_reason = "Mean temp too high {}".format(
background_stats.mean_temp)
return False
# don't process clips with too large of a temperature difference
if self.config.max_temperature_range_threshold and (background_stats.max_temp - background_stats.min_temp > self.config.max_temperature_range_threshold):
self.reject_reason = "Temp delta too high {}".format(
background_stats.max_temp - background_stats.min_temp)
return False
# reset the track ID so we start at 1
Track._track_id = 1
self.tracks = []
self.active_tracks = []
self.region_history = []
# create optical flow
self.opt_flow = cv2.createOptFlow_DualTVL1()
self.opt_flow.setUseInitialFlow(True)
if not self.config.high_quality_optical_flow:
# see https://stackoverflow.com/questions/19309567/speeding-up-optical-flow-createoptflow-dualtvl1
self.opt_flow.setTau(1 / 4)
self.opt_flow.setScalesNumber(3)
self.opt_flow.setWarpingsNumber(3)
self.opt_flow.setScaleStep(0.5)
# process each frame
self.frame_on = 0
for frame in frames:
self.track_next_frame(frame, background)
self.frame_on += 1
# filter out tracks that do not move, or look like noise
self.filter_tracks()
# apply smoothing if required
if self.config.track_smoothing and len(frames) > 0:
frame_height, frame_width = frames[0].shape
for track in self.tracks:
track.smooth(Rectangle(0, 0, frame_width, frame_height))
return True
def flow(prev_frame, cur_frame, tvl1=cv2.createOptFlow_DualTVL1()):
prev_frame = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
cur_frame = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY)
return tvl1.calc(prev_frame, cur_frame, None)
def test_cv2_flann():
"""
Ignore:
[name for name in dir(cv2) if 'create' in name.lower()]
[name for name in dir(cv2) if 'stereo' in name.lower()]
ut.grab_zipped_url('https://priithon.googlecode.com/archive/a6117f5e81ec00abcfb037f0f9da2937bb2ea47f.tar.gz', download_dir='.')
"""
import cv2
from vtool.tests import dummy
import plottool as pt
import vtool as vt
img1 = vt.imread(ut.grab_test_imgpath('easy1.png'))
img2 = vt.imread(ut.grab_test_imgpath('easy2.png'))
stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15)
disparity = stereo.compute(img1, img2)
pt.imshow(disparity)
pt.show()
#cv2.estima
flow = cv2.createOptFlow_DualTVL1()
img1, img2 = vt.convert_image_list_colorspace([img1, img2],
'gray',
src_colorspace='bgr')
img2 = vt.resize(img2, img1.shape[0:2][::-1])
out = img1.copy()
flow.calc(img1, img2, out)
orb = cv2.ORB_create()
kp1, vecs1 = orb.detectAndCompute(img1, None)
kp2, vecs2 = orb.detectAndCompute(img2, None)
detector = cv2.FeatureDetector_create("SIFT")
descriptor = cv2.DescriptorExtractor_create("SIFT")
skp = detector.detect(img1)
skp, sd = descriptor.compute(img1, skp)
tkp = detector.detect(img2)
tkp, td = descriptor.compute(img2, tkp)
out = img1.copy()
cv2.drawKeypoints(img1, kp1, outImage=out)
pt.imshow(out)
vecs1 = dummy.testdata_dummy_sift(10)
vecs2 = dummy.testdata_dummy_sift(10) # NOQA
FLANN_INDEX_KDTREE = 0 # bug: flann enums are missing
#flann_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=4)
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params) # NOQA
cv2.flann.Index(vecs1, index_params)
#cv2.FlannBasedMatcher(flann_params)
cv2.flann.Index(vecs1, flann_params) # NOQA
frames = []
for frame, _ in video:
frames.append(frame.copy())
first = np.float32(frames[0])
second = np.float32(frames[1])
print(np.mean(first))
print(np.mean(second))
first = preprocess(first)
second = preprocess(second)
opt_flow = cv2.createOptFlow_DualTVL1()
opt_flow.setTau(1 / 4)
opt_flow.setScalesNumber(3)
opt_flow.setWarpingsNumber(3)
opt_flow.setScaleStep(0.5)
height = 120
width = 160
flow = np.zeros([height, width, 2], dtype=np.float32)
cv2.setNumThreads(0)
flow = opt_flow.calc(first, second, flow)
t0 = time.time()
cv2.setNumThreads(0)
def new_dense_flow(augs, enableSecond):
'''
use cv2.VideoCapture()
'''
video_name, save_dir, step, bound = augs
video_path = os.path.join(videos_root,
video_name.split('_')[1], video_name)
print(video_path)
videocapture = cv2.VideoCapture(video_path)
fps = videocapture.get(
cv2.CAP_PROP_FPS) # get fps and set gap frame for seconds
print(fps)
if True == enableSecond:
step = step * fps
if not videocapture.isOpened():
print 'Could not initialize capturing! ', video_name
exit()
print(video_name)
frame_num = 0
image, prev_image, gray, prev_gray = None, None, None, None
num0 = 0
while True:
ret, frame = videocapture.read()
if False == ret:
break
num0 += 1
if 0 == frame_num:
image = np.zeros_like(frame)
gray = np.zeros_like(frame)
prev_gray = np.zeros_like(frame)
prev_image = frame
prev_gray = cv2.cvtColor(prev_image, cv2.COLOR_RGB2GRAY)
frame_num += 1
step_t = step
while step_t > 1:
frame = videocapture.read()
num0 += 1
step_t -= 1
continue
image = frame
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
frame_0 = prev_gray
frame_1 = gray
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
save_flows(flowDTVL1, image, save_dir, frame_num,
bound) #this is to save flows and img.
prev_gray = gray
prev_image = image
frame_num += 1
# to pass the out of stepped frames
step_t = step
while step_t > 1:
frame = videocapture.read()
num0 += 1
step_t -= 1
def flow(prev_frame, cur_frame, tvl1=cv2.createOptFlow_DualTVL1()):
prev_frame = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
cur_frame = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY)
return tvl1.calc(prev_frame, cur_frame, None)
def compute_TVL1flow(args):
'''
Parameters (args)
----------
in_path : The path to every video's rgb directory
flow_x_path : The path to flow_x directory that corresponds with every video.
flow_y_path : The path to flow_x directory that corresponds with every video.
Returns
-------
None
'''
bound = 20
in_path, flow_x_path, flow_y_path = args
rgb_frames = os.listdir(in_path)
rgb_frames.sort()
flow = []
tv_l1 = cv2.createOptFlow_DualTVL1()
def obtain_flows(in_path, rgb_frames):
prev_frame = cv2.imread(os.path.join(in_path, rgb_frames[0]))
prev_frame = cv2.UMat(
prev_frame
) # Convert to UMat to speed up computation by small factor
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_RGB2GRAY)
prev_gray = cv2.UMat(prev_gray)
for i, frames in enumerate(rgb_frames):
curr_frame = cv2.imread(os.path.join(in_path, frames))
curr_frame = cv2.UMat(curr_frame)
curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_RGB2GRAY)
curr_gray = cv2.UMat(curr_gray)
tvl1_flow = tv_l1.calc(prev_gray, curr_gray, None)
tvl1_flow = cv2.UMat.get(tvl1_flow)
assert (tvl1_flow.dtype == np.float32)
tvl1_flow = (tvl1_flow + bound) * (255.0 / (2 * bound))
tvl1_flow = np.round(tvl1_flow).astype(int)
tvl1_flow[tvl1_flow >= 255] = 255
tvl1_flow[tvl1_flow <= 0] = 0
prev_gray = curr_gray
flow.append(tvl1_flow)
for i, flow_val in enumerate(flow):
cv2.imwrite(
os.path.join(flow_x_path.format('u'),
"flow_x{:07d}.jpg".format(i)), flow_val[:, :, 0])
cv2.imwrite(
os.path.join(flow_y_path.format('v'),
"flow_y{:07d}.jpg".format(i)), flow_val[:, :, 1])
max_frame_per_dir = 15000 # Smaller groups
# If total number of frames higher, incrementally calculate flows
if len(rgb_frames) > max_frame_per_dir:
for groups in range(int(np.ceil(len(rgb_frames) / max_frame_per_dir))):
rgb_frames_tmp = rgb_frames[groups *
max_frame_per_dir:(groups + 1) *
max_frame_per_dir]
obtain_flows(in_path, rgb_frames_tmp)
print('Obtained flows for {}'.format(in_path))
# Else, directly compute flows
else:
obtain_flows(in_path, rgb_frames)
print('Obtained flows for {}'.format(in_path))
def __init__(self) -> None:
super().__init__()
self.processor = cv2.createOptFlow_DualTVL1()
def dense_flow(augs):
'''
To extract dense_flow images
:param augs:the detailed augments:
video_name: the video name which is like: 'v_xxxxxxx',if different ,please have a modify.
save_dir: the destination path's final direction name.
step: num of frames between each two extracted frames
bound: bi-bound parameter
:return: no returns
'''
video_name, save_dir, step, bound = augs
video_path = os.path.join(videos_root,
video_name.split('_')[1], video_name)
print(video_path)
# provide two video-read methods: cv2.VideoCapture() and skvideo.io.vread(), both of which need ffmpeg support
videocapture = cv2.VideoCapture(video_path)
# if not videocapture.isOpened():
# print 'Could not initialize capturing! ', video_name
# exit()
# try:
# videocapture = skvideo.io.vread(video_path)
# except:
# print '{} read error! '.format(video_name)
# return 0
print video_name
# if extract nothing, exit!
# if videocapture.sum() == 0:
# print 'Could not initialize capturing', video_name
# exit()
# len_frame = len(videocapture)
len_frame = videocapture.get(cv2.CAP_PROP_FRAME_COUNT)
frame_num = 0
image, prev_image, gray, prev_gray = None, None, None, None
num0 = 0
while True:
success, frame = videocapture.read()
# 读取帧是正确的,则返回True;如果文件读取到结尾，它的返回值就为False
if success == False:
print('finished reading frame of video_{}!'.format(video_name))
break
if num0 >= len_frame:
break
# frame = videocapture[num0]
cv2.imshow("img", frame)
cv2.waitKey(20)
# if image is None:
# print("image is None")
# continue;
# print ("image is ok ")
# print (num0)
# print ("\n")
num0 += 1
if frame_num == 0:
image = np.zeros_like(frame)
gray = np.zeros_like(frame)
prev_gray = np.zeros_like(frame)
prev_image = frame
prev_gray = cv2.cvtColor(prev_image, cv2.COLOR_RGB2GRAY)
frame_num += 1
# to pass the out of stepped frames
step_t = step
while step_t > 1:
# frame=videocapture.read()
num0 += 1
step_t -= 1
continue
image = frame
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
frame_0 = prev_gray
frame_1 = gray
##default choose the tvl1 algorithm
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
save_flows(flowDTVL1, image, save_dir, frame_num,
bound) # this is to save flows and img.
prev_gray = gray
prev_image = image
frame_num += 1
# to pass the out of stepped frames
step_t = step
while step_t > 1:
# frame=videocapture.read()
num0 += 1
step_t -= 1
def extract_tracks(self):
"""
Extracts tracks from given source. Setting self.tracks to a list of good tracks within the clip
:param source_file: filename of cptv file to process
:returns: True if clip was successfully processed, false otherwise
"""
assert self.reader, "Must call load before extracting tracks."
self.reject_reason = None
# we need to load the entire video so we can analyse the background.
frames = [frame for frame, offset in self.reader]
self.frame_buffer.thermal = frames
# first we get the background. This requires reading the entire source into memory.
background, background_stats = self.analyse_background(frames)
is_static_background = background_stats.background_deviation < self.STATIC_BACKGROUND_THRESHOLD
self.stats['threshold'] = background_stats.threshold
self.stats['average_background_delta'] = background_stats.background_deviation
self.stats['average_delta'] = background_stats.average_delta
self.stats['mean_temp'] = background_stats.mean_temp
self.stats['max_temp'] = background_stats.max_temp
self.stats['min_temp'] = background_stats.min_temp
self.stats['is_static'] = is_static_background
self.threshold = background_stats.threshold
# if the clip is moving then remove the estimated background and just use a threshold.
if not is_static_background or self.disable_background_subtraction:
background = None
if len(frames) <= 9:
self.reject_reason = "Clip too short {} frames".format(len(frames))
return False
if self.reject_non_static_clips and not is_static_background:
self.reject_reason = "Non static background deviation={:.1f}".format(background_stats.background_deviation)
return False
# don't process clips that are too hot.
if self.MAX_MEAN_TEMPERATURE_THRESHOLD and background_stats.mean_temp > self.MAX_MEAN_TEMPERATURE_THRESHOLD:
self.reject_reason = "Mean temp too high {}".format(background_stats.mean_temp)
return False
# don't process clips with too large of a temperature difference
if self.MAX_TEMPERATURE_RANGE_THRESHOLD and (background_stats.max_temp - background_stats.min_temp > self.MAX_TEMPERATURE_RANGE_THRESHOLD):
self.reject_reason = "Temp delta too high {}".format(background_stats.max_temp - background_stats.min_temp)
return False
# reset the track ID so we start at 1
Track._track_id = 1
self.tracks = []
self.active_tracks = []
self.region_history = []
# create optical flow
self.opt_flow = cv2.createOptFlow_DualTVL1()
self.opt_flow.setUseInitialFlow(True)
if not self.high_quality_optical_flow:
# see https://stackoverflow.com/questions/19309567/speeding-up-optical-flow-createoptflow-dualtvl1
self.opt_flow.setTau(1 / 4)
self.opt_flow.setScalesNumber(3)
self.opt_flow.setWarpingsNumber(3)
self.opt_flow.setScaleStep(0.5)
# process each frame
self.frame_on = 0
for frame in frames:
self.track_next_frame(frame, background)
# filter out tracks that do not move, or look like noise
self.filter_tracks()
# apply smoothing if required
if self.TRACK_SMOOTHING and len(frames) > 0:
frame_height, frame_width = frames[0].shape
for track in self.tracks:
track.smooth(Rectangle(0,0,frame_width, frame_height))
return True
def track(self, original_img, filtered_img, prev_data):
n_objects = self.nObjectsSpinBox.value()
n_k_means = self.nKmeansSpinBox.value()
if self.k_means is None:
self.k_means = cluster.KMeans(n_clusters=n_objects)
elif n_k_means!=self.k_means.n_clusters:
self.k_means = cluster.KMeans(n_clusters=n_k_means)
non_zero_pos = np.transpose(np.nonzero(filtered_img.T))
center_pos = self.k_means.fit(non_zero_pos).cluster_centers_
windows = np.zeros(center_pos.shape)
windows[:] = self.windowHeightSpinBox.value()
windows[:,0] = self.windowWidthSpinBox.value()
gray_img = cv2.cvtColor(original_img, cv2.COLOR_BGR2GRAY)
shape = gray_img.shape
if self.opt_flow is None:
self.opt_flow = cv2.createOptFlow_DualTVL1()
self.flow = np.zeros(shape + (2,))
self.prev_pos = center_pos
else:
self.flow = self.opt_flow.calc(self.prev_img, gray_img, self.flow)
for p,w in zip(self.prev_pos, windows):
region_min_x, region_min_y = (p-w/2).astype(int)
region_max_x, region_max_y = (p+w/2).astype(int)
region_min_x = max(0, region_min_x)
region_min_y = max(0, region_min_y)
roi = self.flow[region_min_y:region_max_y, region_min_x:region_max_x]
roi_shape = roi.shape
print(region_min_x, region_max_x, roi_shape)
vecs = roi.reshape((np.prod(roi_shape[:2]), 2))
dists = np.linalg.norm(vecs, axis=1)
print(np.max(dists))
vec = np.mean(vecs[dists>np.mean(dists)], axis=0)
print(vec)
next_p = p + vec
p[:] = next_p
# lb = (0,0)<=next_p
# ub = next_p<=shape
#
# if lb[0] and ub[0]:
# p[0] = next_p[0]
#
# if lb[1] and ub[1]:
# p[1] = next_p[1]
self.prev_img = gray_img
res = self.prev_pos
out = {
'position': res,
'rect': [
[
p-w/2.,
p+w/2.
]
for p, w in zip(res, windows)
]
}
return out
def generate_flow(img1, img2):
gray1 = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
gray2 = cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY)
flowGenerator = cv2.createOptFlow_DualTVL1()
flow = flowGenerator.calc(gray1, gray2, None)
return flow
def dense_flow(augs):
'''
To extract dense_flow images
:param augs:the detailed augments:
video_name: the video name which is like: 'v_xxxxxxx',if different ,please have a modify.
save_dir: the destination path's final direction name.
step: num of frames between each two extracted frames
bound: bi-bound parameter
:return: no returns
'''
print(augs)
video_name,save_dir,step,bound,reduce_n=augs
save_dir='/nfs/syzhou/github/two-stream-action-recognition/tvl1_flow_own/'
video_path=os.path.join(videos_root,video_name.split('_')[0],video_name)#0代表前面1代表后面
#/nfs/syzhou/github/two-stream-action-recognition/UCF-101_own/dancing/dancing_1.avi
# provide two video-read methods: cv2.VideoCapture() and skvideo.io.vread(), both of which need ffmpeg support
# videocapture=cv2.VideoCapture(video_path)
# if not videocapture.isOpened():
# print 'Could not initialize capturing! ', video_name
# exit()
try:
print(video_path)
videocapture=skvideo.io.vread(video_path)
except:
print('{} read error! '.format(video_name))
return 0
print (video_name)
# if extract nothing, exit!
if videocapture.sum()==0:
print ('Could not initialize capturing',video_name)
exit()
len_frame=len(videocapture)
print(len_frame)
frame_num=0
image,prev_image,gray,prev_gray=None,None,None,None
num0=0
while True:
#frame=videocapture.read()
if num0>=len_frame:
break
frame=videocapture[num0]
#print(frame.size)
num0+=1
if frame_num==0:
image=np.zeros_like(frame)
gray=np.zeros_like(frame)
prev_gray=np.zeros_like(frame)
prev_image=frame
prev_gray=cv2.cvtColor(prev_image,cv2.COLOR_RGB2GRAY)
frame_num+=1
# to pass the out of stepped frames
step_t=step
while step_t>1:
#frame=videocapture.read()
num0+=1
step_t-=1
continue
image=frame
gray=cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)
frame_0=prev_gray
frame_1=gray
#将图片缩小8倍
'''
size = (int(width * 0.3), int(height * 0.5))
shrink = cv2.resize(img, size, interpolation=cv2.INTER_AREA)
print('宽：%d,高：%d'%(im.size[0],im.size[1]))
'''
#print(frame_0.shape)
#print(image.size[0])
width_0=frame_0.shape[0]
heigh_0=frame_0.shape[1]
width_1=frame_1.shape[0]
heigh_1=frame_1.shape[1]
#w 2160 h 4096
size_0=(int(heigh_0/reduce_n),int(width_0/reduce_n))
frame_0=cv2.resize(frame_0,size_0,interpolation=cv2.INTER_AREA)
size_1=(int(heigh_1/reduce_n),int(width_1/reduce_n))
frame_1=cv2.resize(frame_1,size_1,interpolation=cv2.INTER_AREA)
##default choose the tvl1 algorithm
dtvl1=cv2.createOptFlow_DualTVL1()#createOptFlow_DualTVL1()
#dtvl1=cv2.createOptFlow_PCAFlow()
#dtvl1 = cv2.optflow.createOptFlow_DualTVL1( )
flowDTVL1=dtvl1.calc(frame_0,frame_1,None)
print("complete",num0,video_name)
save_flows(flowDTVL1,image,save_dir,frame_num,bound,video_name,reduce_n,width_1,heigh_1) #this is to save flows and img.
prev_gray=gray
prev_image=image
frame_num+=1
# to pass the out of stepped frames
step_t=step
while step_t>1:
#frame=videocapture.read()
num0+=1
step_t-=1
os.mkdir(maindir + '/Data/Flow')
output = maindir + '/Data/Flow'
dirrr = maindir + '/Data/Resize'
framename = os.listdir(dirrr)
framename.sort()
prvs = cv2.imread(os.path.join(dirrr, framename[0]), cv2.IMREAD_GRAYSCALE)
hsv = np.zeros_like(
cv2.imread(os.path.join(dirrr, framename[0]), cv2.IMREAD_UNCHANGED))
hsv[..., 1] = 255
framename = framename[1:]
for frame in tqdm(framename):
inimg = os.path.join(dirrr, frame)
outimg = os.path.join(output, frame)
next = cv2.imread(inimg, cv2.IMREAD_GRAYSCALE)
flow = np.zeros_like(prvs)
dualTV = cv2.createOptFlow_DualTVL1()
flow = dualTV.calc(prvs, next, flow)
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(outimg, rgb)
prvs = next
def dense_flow(video_list, activity):
base_path = "D:/HMDB51/videos/" + activity + "/"
for i in range(0, len(video_list)):
#capture video information
videocapture = cv2.VideoCapture(base_path + video_list[i])
print(base_path + video_list[i])
frame_width = int(videocapture.get(3))
frame_height = int(videocapture.get(4))
len_frame = number_of_frames = int(
videocapture.get(cv2.CAP_PROP_FRAME_COUNT))
#instantiate a video writer
out = cv2.VideoWriter(base_path + "/flow/"
"flow_" + video_list[i],
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30,
(frame_width, frame_height))
#iterate over frames
image, prev_image, gray, prev_gray = None, None, None, None
frame_num = 0
for ziv in range(0, len_frame):
ret, frame = videocapture.read() #reading frames
#getting first frame
if frame_num == 0:
prev_image = frame
#cv2.imshow('image', frame)
prev_gray = cv2.cvtColor(prev_image, cv2.COLOR_RGB2GRAY)
frame_num += 1
continue
image = frame
blank_image = np.zeros((frame_height, frame_width, 3), np.uint8)
try:
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
frame_0 = prev_gray
frame_1 = gray
##default choose the tvl1 algorithm
dtvl1 = cv2.createOptFlow_DualTVL1()
flowDTVL1 = dtvl1.calc(frame_0, frame_1, None)
flow_x = ToImg(flowDTVL1[..., 0], bound)
flow_y = ToImg(flowDTVL1[..., 1], bound)
#flow_x_img=Image.fromarray(flow_x)
#flow_y_img=Image.fromarray(flow_y)
#flow_x_img = rescale_flow(flow_x_img)
#flow_y_img = rescale_flow(flow_y_img)
#print(np.shape(flowDTVL1[...,0]))
blank_image[:, :, 0] = flow_x
blank_image[:, :, 1] = np.zeros_like(flow_x)
blank_image[:, :, 2] = flow_y
out.write(blank_image)
#save_flows(flowDTVL1,image,save_dir,frame_num,bound) #this is to save flows and img.
prev_gray = gray
prev_image = image
frame_num += 1
except:
print("frame is already in grayscale")
out.release()
videocapture.release()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--dataset",
type=str,
default="youtube",
help="dataset to parse flow")
args = parser.parse_args()
data_root = Path("data/{}_tempered".format(args.dataset))
im_root = data_root / "vid"
flow_root = data_root / "flow"
fn_read = lambda x: cv2.cvtColor(cv2.imread(str(x)), cv2.COLOR_BGR2GRAY)
dtvl1 = cv2.createOptFlow_DualTVL1()
for cnt, vid in enumerate(tqdm(im_root.iterdir())):
print(cnt, " : ", vid)
vid_name = vid.name
this_flow_dir = flow_root / vid_name
this_flow_dir.mkdir(exist_ok=True, parents=True)
files = sorted(vid.iterdir(), key=lambda x: int(x.stem))
first_file = files[0]
prev_im = fn_read(first_file)
for i in range(1, len(files)):
fp = files[i]
img = fn_read(fp)
def findOpticalFlow(inputImage1,
inputImage2,
outputWarpedImage,
outputFlowImage,
verbose,
opticalFlowImplementation="simpleflow"):
oiioImageBuffer1 = ImageBuf( inputImage1 )
ImageBufReorient(oiioImageBuffer1, oiioImageBuffer1.orientation)
oiioImageBuffer2 = ImageBuf( inputImage2 )
ImageBufReorient(oiioImageBuffer2, oiioImageBuffer2.orientation)
if verbose:
print( "load and convert 1 - %s" % inputImage1 )
openCVImageBuffer1 = OpenCVImageBufferFromOIIOImageBuffer(oiioImageBuffer1)
if verbose:
print( "load and convert 2 - %s" % inputImage2 )
openCVImageBuffer2 = OpenCVImageBufferFromOIIOImageBuffer(oiioImageBuffer2)
if verbose:
print( "resolution : %s" % str(openCVImageBuffer1.shape) )
print( "calculate optical flow 1 -> 2")
if opticalFlowImplementation == "old_farneback":
if verbose:
print( "older farneback implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
previous_flow = None
pyramid_scale = 0.5
pyramid_levels = 5
window_size = 50
iterations_per_pyramid_level = 20
pixel_neighborhood_size = 3
neighborhood_match_smoothing_factor = 1.0
flags = cv2.OPTFLOW_FARNEBACK_GAUSSIAN
if verbose:
print( "calculate")
opencvFlow = cv2.calcOpticalFlowFarneback(gray1, gray2,
previous_flow, pyramid_scale, pyramid_levels, window_size, iterations_per_pyramid_level,
pixel_neighborhood_size, neighborhood_match_smoothing_factor, flags)
elif opticalFlowImplementation == "farneback":
if verbose:
print( "farneback implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
# Set of constants should be added
implementation = cv2.optflow.createOptFlow_Farneback()
if verbose:
print( "calculate")
opencvFlow = implementation.calc(gray1, gray2, None)
elif opticalFlowImplementation == "dualtvl1":
if verbose:
print( "dualtvl1 implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
# Set of constants should be added
implementation = cv2.createOptFlow_DualTVL1()
if verbose:
print( "calculate")
opencvFlow = implementation.calc(gray1, gray2, None)
elif opticalFlowImplementation == "sparsetodense":
if verbose:
print( "sparse to dense implementation" )
# Current set of constants... Ranges and good values should be documented
if verbose:
print( "calculate")
opencvFlow = cv2.optflow.calcOpticalFlowSparseToDense(openCVImageBuffer1, openCVImageBuffer2, None,
8, 128, 0.05, True, 500.0, 1.5)
elif opticalFlowImplementation == "deepflow":
if verbose:
print( "deep flow implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
# Set of constants should be added
implementation = cv2.optflow.createOptFlow_DeepFlow()
if verbose:
print( "calculate")
opencvFlow = implementation.calc(gray1, gray2, None)
elif opticalFlowImplementation == "dis":
if verbose:
print( "dis implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
# Set of constants should be added
implementation = cv2.optflow.createOptFlow_DIS()
if verbose:
print( "calculate")
opencvFlow = implementation.calc(gray1, gray2, None)
elif opticalFlowImplementation == "pcaflow":
if verbose:
print( "pca flow implementation" )
if verbose:
print( "to grey 1")
gray1 = cv2.cvtColor(openCVImageBuffer1, cv2.COLOR_BGR2GRAY)
if verbose:
print( "to grey 2")
gray2 = cv2.cvtColor(openCVImageBuffer2, cv2.COLOR_BGR2GRAY)
# Set of constants should be added
implementation = cv2.optflow.createOptFlow_PCAFlow()
if verbose:
print( "calculate")
opencvFlow = implementation.calc(gray1, gray2, None)
elif opticalFlowImplementation == "simpleflow":
if verbose:
print( "simple flow implementation" )
# Current set of constants... Ranges and good values should be documented
opencvFlow = cv2.optflow.calcOpticalFlowSF(openCVImageBuffer1, openCVImageBuffer2,
3, 2, 4, 4.1, 25.5, 18, 55.0, 25.5, 0.35, 18, 55.0, 25.5, 10)
else:
print( "Unknown optical flow implementation : %s" % opticalFlowImplementation )
opencvFlow = None
if outputWarpedImage and (opencvFlow is not None):
if verbose:
print( "warping 1 -> 2")
opencvWarped = applyOpticalFlow(openCVImageBuffer1, opencvFlow)
if verbose:
print( "converting and writing warped image - %s" % outputWarpedImage )
oiioWarped = OIIOImageBufferFromOpenCVImageBuffer( opencvWarped )
oiioWarped.write( outputWarpedImage )
else:
opencvWarped = None
if outputFlowImage and (opencvFlow is not None):
if verbose:
print( "converting and writing flow image - %s" % outputFlowImage )
oiioFlowBuffer = OIIOImageBufferFromOpenCVImageBuffer( opencvFlow )
oiioFlowBuffer.write( outputFlowImage )
return (opencvWarped, opencvFlow)
