def dense_flow(self, algo, **kwargs):
if algo == "farnebeck":
denseFlow = cv.FarnebackOpticalFlow_create(**kwargs)
elif algo == "dualtvl1":
denseFlow = cv.optflow.DualTVL1OpticalFlow_create(**kwargs)
else:
raise ValueError("pick an algorithm 'dualtvl1' or 'farnebeck'")
return denseFlow
def burst_flows_to_shm(vid_path, alg_type, temp_burst_dir, image_ext,
flow_size):
try:
cap = cv2.VideoCapture(vid_path)
if alg_type == 'farn':
optical_flow_hdl = cv2.FarnebackOpticalFlow_create(
pyrScale=0.702,
numLevels=5,
winSize=10,
numIters=2,
polyN=5,
polySigma=1.1,
flags=cv2.OPTFLOW_FARNEBACK_GAUSSIAN)
elif alg_type == 'tvl1':
optical_flow_hdl = cv2.DualTVL1OpticalFlow_create()
else:
raise NotImplementedError(
'optical flow algorithm {} is not implemented.'.format(
alg_type))
ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
prvs = resize_by_short_edge(prvs, flow_size)
hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
idx = 1
while True:
ret, frame2 = cap.read()
if not ret:
break
next = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
next = resize_by_short_edge(next, flow_size)
flow = optical_flow_hdl.calc(prvs, next, None)
"""
flow_x = cv2.normalize(flow[..., 0], None, 0, 255, cv2.NORM_MINMAX)
flow_y = cv2.normalize(flow[..., 1], None, 0, 255, cv2.NORM_MINMAX)
flow_x = flow_x.astype('uint8')
flow_y = flow_y.astype('uint8')
video_flow_list.append([flow_x,flow_y])
"""
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.imwrite(
os.path.join(temp_burst_dir,
'{:04d}{}'.format(idx, image_ext)), bgr)
prvs = next
idx += 1
except Exception as e:
print(repr(e))
class PointTrackerFarneback:
params__ = dict(pyrScale=0.5,
numLevels=3,
winSize=15,
numIters=3,
polyN=5,
polySigma=1.2,
flags=0,
fastPyramids=True)
__optflow = cv2.FarnebackOpticalFlow_create(**params__)
def track(self, prevImg, nextImg, prevPts):
flow = self.__optflow.calc(prevImg, nextImg, None)
pointsAtPixels = prevPts.round().astype(np.int32)
x = pointsAtPixels[:, 0]
y = pointsAtPixels[:, 1]
ptsFlow = flow[(y, x)]
pts = np.add(prevPts, ptsFlow)
status = np.ones(len(pts), np.uint8)
return pts, status
print(f"Frame height: {frame_height}")
cv2.namedWindow("Frame", cv2.WINDOW_NORMAL)
cv2.namedWindow("Dense optical flow", cv2.WINDOW_NORMAL)
# Parameters for Farnerback optical flow
feature_params = dict(pyrScale=0.5,
numLevels=3,
winSize=15,
numIters=3,
polyN=5,
polySigma=1.2,
flags=0)
# Create Farnerback optical flow
optical_flow = cv2.FarnebackOpticalFlow_create(**feature_params)
# First frame in the sequence
ret, first_frame = cap.read()
# Converts frame to gray
prev_gray = cv2.cvtColor(first_frame, cv2.COLOR_BGR2GRAY)
# Creates an image filled with zeroes for drawing purposes
mask = np.zeros_like(first_frame)
# Sets mask saturation to maximum
mask[..., 1] = 255
while True:
ret, frame = cap.read()
#Importuojamos reikalingos bibliotekos
import numpy as np
import cv2 as cv
import flowlib as fl
import matplotlib.pyplot as plt
#Tyrimo pavyzdžiai
datasets = ("Dimetrodon", "Grove2", "Grove3", "Hydrangea", "RubberWhale",
"Urban2", "Urban3", "Venus")
#Sukuriami optinio srauto algoritmų objektai
ofDis = cv.DISOpticalFlow.create(cv.DISOPTICAL_FLOW_PRESET_MEDIUM)
ofFb = cv.FarnebackOpticalFlow_create()
ofTvl = cv.optflow.DualTVL1OpticalFlow_create()
ofDf = cv.optflow.createOptFlow_DeepFlow()
ofPca = cv.optflow.createOptFlow_PCAFlow()
ofSf = cv.optflow.createOptFlow_SimpleFlow()
ofSd = cv.optflow.createOptFlow_SparseToDense()
#Funkcija optinio srauto algoritmų tikslumo vertinimui
def evaluate_of(of_alg, name):
print("\nEvaluating: " + name + " algorithm:")
sum_mepe = 0
for dataset in datasets:
first = cv.imread('./data/' + dataset + "/frame10.png",
cv.IMREAD_GRAYSCALE)
second = cv.imread('./data/' + dataset + "/frame11.png",
cv.IMREAD_GRAYSCALE)
flow_gt = cv.readOpticalFlow('./flow/' + dataset + '/flow10.flo')
#flow_gt_img = fl.flow_to_image(flow_gt)