def get_mean(vid_file):
"""Return the average frame across the whole video."""
vid = cv2.VideoCapture(vid_file)
num_frames = vid.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)
retval, im = vid.read()
mean = np.zeros((len(im), len(im[0]), 3))
num = 1.0
cv2.accumulate(im,mean)
frame = 0
while retval:
frame += 1
sys.stdout.write('\rgetting mean: ' + `(frame * 100) / int(num_frames)` + '%')
sys.stdout.flush()
cv2.accumulate(im, mean)
num += 1
retval, im = vid.read()
print '\ndone getting mean'
mean = mean / num
mean = mean.astype("uint8")
vid.release()
return mean
def callback(image_wv1, image_wv2, image_wv3, image_wv4, image_wv5):
stamp = image_wv1.header.stamp
cv_img_wv1 = bridge.imgmsg_to_cv2(image_wv1, desired_encoding="bgr8")
cv_img_wv1 = cv.cvtColor(cv_img_wv1, cv.COLOR_BGR2GRAY)
cv_img_wv2 = bridge.imgmsg_to_cv2(image_wv2, desired_encoding="bgr8")
cv_img_wv2 = cv.cvtColor(cv_img_wv2, cv.COLOR_BGR2GRAY)
cv_img_wv3 = bridge.imgmsg_to_cv2(image_wv3, desired_encoding="bgr8")
cv_img_wv3 = cv.cvtColor(cv_img_wv3, cv.COLOR_BGR2GRAY)
cv_img_wv4 = bridge.imgmsg_to_cv2(image_wv4, desired_encoding="bgr8")
cv_img_wv4 = cv.cvtColor(cv_img_wv4, cv.COLOR_BGR2GRAY)
cv_img_wv5 = bridge.imgmsg_to_cv2(image_wv5, desired_encoding="bgr8")
cv_img_wv5 = cv.cvtColor(cv_img_wv5, cv.COLOR_BGR2GRAY)
#Fusion
cv_img_merged = np.zeros(cv_img_wv1.shape)
cv.accumulate(cv_img_wv1, cv_img_merged);
cv.accumulate(cv_img_wv2, cv_img_merged);
cv.accumulate(cv_img_wv3, cv_img_merged);
cv.accumulate(cv_img_wv4, cv_img_merged);
cv.accumulate(cv_img_wv5, cv_img_merged);
cv_img_merged = cv_img_merged/5
cv_img_merged = cv_img_merged.astype(np.uint8)
#Publish
message = bridge.cv2_to_imgmsg(cv_img_merged, encoding="mono8")
message.header.stamp = stamp
pub.publish(message)
def plot(self, colorPatches):
print self
# print "Cluster %i has %i components" % (self.clusterID, self.count)
enlargeFactor = 4
bigN = 15 * enlargeFactor
bigImage = np.zeros((bigN, bigN * self.count, 3), np.uint8)
accumu = np.zeros(colorPatches[0].shape, np.float)
for i in range(self.count):
cv2.accumulate(colorPatches[self.components[i]], accumu)
bigImage[:, i * bigN:(i + 1) * bigN] = cv2.resize(
colorPatches[self.components[i]],
None,
fx=enlargeFactor,
fy=enlargeFactor,
interpolation=cv2.INTER_CUBIC)
self.avgImg = (accumu / self.count).astype(np.uint8)
cv2.imshow('Cluster' + str(self.clusterID), bigImage)
cv2.imshow(
'Rescaled Average image' + str(self.clusterID),
cv2.resize(self.avgImg,
None,
fx=enlargeFactor,
fy=enlargeFactor,
interpolation=cv2.INTER_CUBIC))
WaitKey(0)
def accumulate_frames(camera, averaged_image, method='accumulate', alpha='1'):
"""
Obtain an averaged frame from a webcam, with
:param camera: cv2.VideoCapture()
Camera object created with cv2.VideoCapture('camera_index')
:param alpha: float [0:1]
defines persistence of background. In other words, how long before a frame is forgotten (1 = never)
:param color : string
defines output pixel data
possible values: 'RGB', 'BGR', 'avg', 'r', 'g', 'b',
'BGR' - no transformation, image given as BGR color coding
'RGB' - transforms color coding into RGB
'sum' - averages all colors and returns single value per pixel
'r' - returns only red channel
'g' - returns only green channel
'b' - returns only blue channel
:return: np.array
array of pixels with data as defined by color method
"""
_, frame = camera.read()
# avg_img = np.float32(frame)
if method == 'accumulate':
cv2.accumulate(frame, averaged_image)
elif method == 'accumulateWeighted':
cv2.accumulateWeighted(frame, averaged_image, alpha)
elif method == 'accumulateProduct':
cv2.accumulateProduct(frame, averaged_image, alpha)
elif method == 'accumulateSquare':
cv2.accumulateSquare(frame, averaged_image, alpha)
else:
raise ValueError(
'Unknown accumulation method, please use one of: \n\taccumulate \n\taccumulateSquare \n\taccumulateProduct, \n\taccumulateWeighted'
)
return averaged_image
def get_simple_diff_mask(self, image):
"""
Calculate a mask for the image based on the difference with previous ones.
TODO: Move to Hand class
:param image: image to get the mask
:return: mask based on the difference with previous frames
"""
mask = None
if len(self.last_frames) < self.discarded_frames:
self.last_frames.append(image)
mean_image = np.zeros(image.shape, dtype=np.float32)
for old_image in self.last_frames:
cv2.accumulate(old_image, mean_image)
self.first_frame = mean_image / len(self.last_frames)
else:
blur_radius = 5
blurred_image = cv2.GaussianBlur(image, (blur_radius, blur_radius),
0)
blurred_background = cv2.GaussianBlur(self.first_frame,
(blur_radius, blur_radius),
0)
diff = cv2.absdiff(blurred_image,
blurred_background.astype(np.uint8))
# print "diff"
gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
if self.debug:
cv2.imshow("DEBUG: HandDetection_lib: diff", gray_diff)
# TODO: ENV_DEPENDENCE: it could depend on the lighting and environment
_, mask = cv2.threshold(gray_diff, 40, 255, cv2.THRESH_BINARY)
return mask
def get_tempo(vid_file):
"""Return the tempo property which is dependent on difference frames."""
vid = cv2.VideoCapture(vid_file)
num_frames = vid.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)
width = vid.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)
height = vid.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)
num_pixels = width * height * 3
retval, im1 = vid.read()
retval, im2 = vid.read()
total = np.zeros((height, width, 3))
cv2.accumulate(im1, total)
frame = 0
while retval:
frame += 1
sys.stdout.write('\rgetting tempo: ' + `(frame * 100) / int(num_frames)` + '%')
sys.stdout.flush()
cv2.accumulate(cv2.subtract(im2,im1), total)
im1 = im2
retval, im2 = vid.read()
print '\ndone getting tempo'
vid.release()
tempo = np.sum(total) / (num_pixels * num_frames * 255.0)
return tempo
def avgBackground(self, I):
# read background pic of I,and then calculate frame difference of current frame and pre frame: I and IprevF
# accumulate every frame difference Iscratch2 to sum of differences :IdiffF
# meanwhile,accumulate every frame I to sum of frames :IavgF
"""
Parameters
--------------
I: input Mat type pic stream
Returns
-------
Examples
--------
"""
#学习平均背景步骤：
# 1，使用cv2.accumulate函数累积每一参与学习的帧 ，之后会根据帧数做平均(IavgF)
# 2，使用cv2.absdiff函数获取当前帧(I)与前一帧(IprevF)的帧差(Iscratch2)
# 3,再次使用cv2.accumulate函数对帧差(Iscratch2)做累积，之后会根据帧数(Icount)做平均得到(IdiffF)
cv2.accumulate(I, self.IavgF)
# cv2.absdiff(I,IprevF, Iscratch2)
self.Iscratch2 = cv2.absdiff(I, self.IprevF)
cv2.accumulate(self.Iscratch2, self.IdiffF)
# print("IavgF[100,100,0]:", self.IavgF[100, 100, 0])
# print("IdiffF[100,100,0]:", self.IdiffF[100, 100, 0])
self.Icount += 1.0
self.IprevF = I.copy()
def acc_back(self, frame):
if self.i_prev_f != None:
cv2.accumulate(frame, self.i_avg_f)
diff = cv2.absdiff(frame, self.i_prev_f)
cv2.accumulate(diff, self.i_diff_f)
self.i_cnt += 1
self.i_prev_f = frame.copy()
def run_avg(image,wt):
global bg
if bg is None:
bg=image.copy().astype('float')
return
cv2.accumulate(image,bg,wt)
def get_simple_diff_mask2(self, image):
"""
TODO: Move to Hand class
:param image:
:return:
"""
mask = None
# TODO: ENV_DEPENDENCE: it could depend on the lighting and environment
blur_radius = 5
if len(self.last_frames) > 0:
mean_image = np.zeros(image.shape, dtype=np.float32)
for old_image in self.last_frames:
cv2.accumulate(old_image, mean_image)
result_image = mean_image / len(self.last_frames)
result_image = result_image.astype(np.uint8)
# cv2.imshow("mean_image", result_image.astype(np.uint8))
# cv2.imshow("the image", image)
blurred_image = cv2.GaussianBlur(image, (blur_radius, blur_radius),
0)
blurred_background = cv2.GaussianBlur(result_image,
(blur_radius, blur_radius),
0)
# cv2.imshow("b_mean_image", blurred_background)
# cv2.imshow("b_the image", blurred_image)
diff = cv2.absdiff(blurred_image,
blurred_background.astype(np.uint8))
# cv2.imshow("diff", diff)
# print "diff"
gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
# cv2.imshow("gray_diff", gray_diff)
# TODO: ENV_DEPENDENCE: it could depend on the lighting and environment
_, mask = cv2.threshold(gray_diff, 40, 255, cv2.THRESH_BINARY)
non_zero_pixels = cv2.countNonZero(mask)
non_zero_percent = (non_zero_pixels * 100.) / (image.shape[0] *
image.shape[1])
if non_zero_percent < 1:
self.first_frame = result_image
elif non_zero_percent > 95:
self.reset_background()
# print "Non zero pixel percentage %d" % non_zero_percent
if self.first_frame is not None:
blurred_image = cv2.GaussianBlur(image, (blur_radius, blur_radius),
0)
blurred_background = cv2.GaussianBlur(self.first_frame,
(blur_radius, blur_radius),
0)
diff = cv2.absdiff(blurred_image,
blurred_background.astype(np.uint8))
# print "diff"
gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
# cv2.imshow("diff", gray_diff)
# TODO: ENV_DEPENDENCE: it could depend on the lighting and environment
_, mask = cv2.threshold(gray_diff, 40, 255, cv2.THRESH_BINARY)
else:
self.last_frames.append(image)
return mask
def summarize(self, colorPatches):
# get average image
accumu = np.zeros(colorPatches[0].shape, np.float)
for i in range(self.count):
cv2.accumulate(colorPatches[self.components[i]], accumu)
self.avgImg = (accumu/self.count).astype(np.uint8)
# get hist
W,H,_ = colorPatches[0].shape
self.bigImage = np.zeros((W, H*self.count, 3), np.uint8)
for i in range(self.count):
self.bigImage[:, i*H : (i+1)*H, :] = colorPatches[self.components[i]]
bigImageHSV = cv2.cvtColor(self.bigImage, cv2.COLOR_BGR2HSV)
self.hist = cv2.calcHist([bigImageHSV], [0,1], None, [180, 256],[0, 180,0,256])
def learn(self):
if self.done:
raise Exception('already done!')
cv2.accumulate(self.motion_detector.prev_frame, self.__accumulated)
self.frames_learned = self.frames_learned + 1
if self.motion_detector.motion_started():
self.learned = self.__average(self.__accumulated,
self.frames_learned)
self.done = True
self.__accumulated = None
return self.done
def learn(self, frame, foregroundMask=None):
if self.__framesHistoryAccumulator is None:
self.__framesHistoryAccumulator = np.zeros(frame.shape, np.float32)
self.learned = np.zeros(frame.shape, np.uint8)
history = self.__framesHistory
accumulator = self.__framesHistoryAccumulator
if len(history) == history.maxlen: # if frames queue is full
oldestFrame, bgMask = history.popleft()
cv2.subtract(accumulator, oldestFrame, dst=accumulator, dtype=cv2.CV_32F,
mask=bgMask) # remove old frame from accum
bgMask = cv2.bitwise_not(foregroundMask)
history.append((frame, bgMask))
cv2.accumulate(frame, accumulator, mask=bgMask) # accumulate frames sum
self.learned = np.true_divide(accumulator, len(history), out=self.learned, casting='unsafe') # average frame
def summarize(self, colorPatches):
# get average image
accumu = np.zeros(colorPatches[0].shape, np.float)
for i in range(self.count):
cv2.accumulate(colorPatches[self.components[i]], accumu)
self.avgImg = (accumu / self.count).astype(np.uint8)
# get hist
W, H, _ = colorPatches[0].shape
self.bigImage = np.zeros((W, H * self.count, 3), np.uint8)
for i in range(self.count):
self.bigImage[:, i * H:(i + 1) *
H, :] = colorPatches[self.components[i]]
bigImageHSV = cv2.cvtColor(self.bigImage, cv2.COLOR_BGR2HSV)
self.hist = cv2.calcHist([bigImageHSV], [0, 1], None, [180, 256],
[0, 180, 0, 256])
def accumulate_static(self, frame):
"""Accumulate frames for averaging for static analysis of the playing field.
Only calculates the result once every avg frames. If reset is True, will purge old results.
:arg frame: A frame of type CV_8UC3 and size self.shape
:arg reset: Reset averaging
"""
self.counter += 1
cv2.accumulate(frame, self.accumulator) # Is faster than uint16/uint8 ops in numpy
#self.accumulator += frame
if not self.counter % self.avg: # if avg samples have been collected
self._run_process_static()
self.counter = 0
self.accumulator = np.zeros(frame.shape, dtype=np.float32)
def composePicture(pics):
print(pics[0].shape[0:2])
ret_mat = np.zeros(pics[0].shape[0:2])
for pic in pics:
pic = cv2.cvtColor(pic, cv2.COLOR_BGR2GRAY)
print(pic.shape)
ret_mat = cv2.accumulate(pic, ret_mat)
ret_mat = ret_mat / len(pics)
return ret_mat
def main(videofile):
# Initialize video stream
cap = cv2.VideoCapture(videofile)
frame = get_frame(cap)
avg1 = np.float32(frame)
avg2 = np.float32(frame)
accum = np.float32(frame)
num_bg_samples = 20
for _ in xrange(num_bg_samples):
frame = get_frame(cap)
cv2.accumulate(frame, accum)
bg = cv2.convertScaleAbs(accum / float(num_bg_samples))
bgmean = bg.mean()
bgstd = bg.std()
cv2.imshow("Background", bg)
while True:
frame = get_frame(cap)
fg = cv2.convertScaleAbs(bg - frame)
_, fgbin = cv2.threshold(fg, bgmean + bgstd, 255, cv2.THRESH_BINARY)
# cv2.accumulateWeighted(frame, avg1, 0.1)
# cv2.accumulateWeighted(frame, avg2, 0.01)
# res1 = cv2.convertScaleAbs(avg1)
# res2 = cv2.convertScaleAbs(avg2)
cv2.imshow('img', frame)
cv2.imshow("FG", fg)
cv2.imshow("FG bin", fgbin)
# cv2.imshow('avg1',res1)
# cv2.imshow('avg2',res2)
key = cv2.waitKey(10)
if key == 27:
break
if key == ord(" "):
cv2.imwrite("screenshot.jpg", frame)
def main(videofile):
# Initialize video stream
cap = cv2.VideoCapture(videofile)
frame = get_frame(cap)
avg1 = np.float32(frame)
avg2 = np.float32(frame)
accum = np.float32(frame)
num_bg_samples = 20
for _ in xrange(num_bg_samples):
frame = get_frame(cap)
cv2.accumulate(frame, accum)
bg = cv2.convertScaleAbs(accum / float(num_bg_samples))
bgmean = bg.mean()
bgstd = bg.std()
cv2.imshow("Background", bg)
while True:
frame = get_frame(cap)
fg = cv2.convertScaleAbs(bg - frame)
_, fgbin = cv2.threshold(fg, bgmean + bgstd, 255, cv2.THRESH_BINARY)
# cv2.accumulateWeighted(frame, avg1, 0.1)
# cv2.accumulateWeighted(frame, avg2, 0.01)
# res1 = cv2.convertScaleAbs(avg1)
# res2 = cv2.convertScaleAbs(avg2)
cv2.imshow('img',frame)
cv2.imshow("FG", fg)
cv2.imshow("FG bin", fgbin)
# cv2.imshow('avg1',res1)
# cv2.imshow('avg2',res2)
key = cv2.waitKey(10)
if key == 27:
break
if key == ord(" "):
cv2.imwrite("screenshot.jpg", frame)
def vio_sensor_cb(data):
global cnt, active, imgs
num_samples = 100 # number of image samples to take
if cnt == num_samples and active:
imgs['l'] /= num_samples
imgs['r'] /= num_samples
active = 0
return
left = np.float32(CvBridge().imgmsg_to_cv2(data.left_image, "mono8"))
right = np.float32(CvBridge().imgmsg_to_cv2(data.right_image, "mono8"))
if cnt == 0:
imgs['l'] = left
imgs['r'] = right
else:
cv2.accumulate(left, imgs['l'])
cv2.accumulate(right, imgs['r'])
cnt += 1
def calculate_mean_over_interval(vid_frames):
width, height = get_frame_dimensions(vid_frames[0])
sum_of_frames = np.zeros((height, width, 3), np.float64)
mean_of_frames = np.zeros((height, width, 3), np.float)
i = 0
for frame in vid_frames:
sum_of_frames = cv2.accumulate(frame, sum_of_frames)
i += 1
# print("Sum: " + str(sum_of_frames[0, 0]))
mean_of_frames = sum_of_frames / i
return mean_of_frames
def main(videofile):
# Initialize video stream
cap = cv2.VideoCapture(videofile)
# Get video stream width and height
width = cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)
height = cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)
edge_counts = np.zeros((height, width))
num_bg_samples = 50
for _ in xrange(num_bg_samples):
cv2.accumulate(get_edge_frame(cap) / 255.0, edge_counts)
bg_prob = edge_counts / float(num_bg_samples)
print bg_prob.min()
print bg_prob.max()
bg_thresh = 0.5
bg_pixels = bg_prob > bg_thresh
while True:
frame = get_frame(cap)
cv2.imshow("Original", frame)
edge_img = cv2.Canny(frame, 40, 100)
cv2.imshow("Raw edges", edge_img)
edge_nobg = edge_img.copy()
edge_nobg[bg_pixels] = 0
cv2.imshow("Edges no bg", edge_nobg)
key = cv2.waitKey(10)
if key == 27:
break
if key == ord(" "):
cv2.imwrite("screenshot.jpg", edge_img)
def pile_up(self, new_frame):
"""
Add a new frame to the current accumulation
@rtype: integer, number of frames
@param new_frame:
@return: number of frames in the current pile
"""
# Kill black level before the accumulation
cv2.equalizeHist(new_frame, self.frame_eq)
# Do the accumulation with motion compensation
# -- we offset the previous accumulation
if self.motion_comp and self.n_fused_frames > 0:
b_success = self.compensate_interframe_motion(
new_frame, 'shi_tomasi')
if b_success:
print "Frames aligned"
else:
print "Frames not aligned"
# Handle a reset of the accumulation (TODO : Make it automatic if the scene changes a lot)
if self.reset:
self.frame_acc = np.float32(new_frame)
self.reset = False
# Pile up
cv2.accumulate(new_frame, self.frame_acc) # Just add pixel values
cv2.normalize(np.power(self.frame_acc, self.gamma),
self.frame_acc_disp, 0., 1., cv2.NORM_MINMAX)
# Update and return
self.n_fused_frames += 1
self.frame_prev = new_frame
return self.n_fused_frames
def pile_up(self, new_frame):
"""
Add a new frame to the current accumulation
@rtype: integer, number of frames
@param new_frame:
@return: number of frames in the current pile
"""
# Kill black level before the accumulation
cv2.equalizeHist(new_frame, self.frame_eq)
# Do the accumulation with motion compensation
# -- we offset the previous accumulation
if self.motion_comp and self.n_fused_frames > 0:
b_success = self.compensate_interframe_motion(new_frame, self.motion_compensation_method)
if b_success:
print "Frames aligned"
else:
print "Frames not aligned"
# Handle a reset of the accumulation
# TODO: Make it automatic if the scene changes a lot
if self.reset:
self.frame_acc = np.float32(new_frame)
self.reset = False
# Pile up
cv2.accumulate(new_frame, self.frame_acc) # Just add pixel values
cv2.normalize(np.power(self.frame_acc, self.gamma), self.frame_acc_disp, 0., 1., cv2.NORM_MINMAX)
# Update and return
self.n_fused_frames += 1
self.frame_prev = new_frame
return self.n_fused_frames
def meanBackground(capture):
# 获取视频长度
frameNum = capture.get(cv2.CAP_PROP_FRAME_COUNT)
success, frame = capture.read()
# 初始化平均背景图像，初始化图像为视频首帧图像
meanFrame = frame
# 在后续处理中为了防止数值溢出，先进行数据类型转化，转为float32型，在处理完成后在转化为unint8格式进行保存
meanFrame = meanFrame.astype(np.float32)
cv2.imshow('original image', meanFrame)
while True:
# Capture frame-by-frame
ret, frame = capture.read()
if ret == True:
tempframe = frame
tempframe = tempframe.astype(np.float32)
# 将所有帧的图像进行叠加
cv2.accumulate(tempframe, meanFrame)
cv2.imshow('original video', frame)
cv2.imshow('temp frame', tempframe)
cv2.imshow('mean video', meanFrame)
# Press Q on keyboard to exit
if cv2.waitKey(33) & 0xFF == ord('q'):
break
# Break the loop
else:
break
# cv2.imshow('accumulate image', meanFrame)
# cv2.waitKey(0)
meanFrame = meanFrame / frameNum # 对叠加后的图像进行求平均
meanFrame = meanFrame.astype(np.uint8) # 从float32转为uint8格式
cv2.imshow('result image', meanFrame)
cv2.waitKey(300)
cv2.imwrite('resultImage.jpg', meanFrame)
def mean_image(img_array, img_shape=(28, 28, 1)):
"""Accept images as numpy array with images separated by rows
and columns indicating pixel values"""
assert (type(img_array) is type(pd.DataFrame())), TypeError
# pre-allocate mean_img
mean_img = np.zeros(img_shape, dtype=np.float32)
# process files
print(f"Computing mean image...")
for file_count, idx in enumerate(range(img_array.shape[0])):
temp_img = np.reshape(img_array.iloc[idx].to_numpy(), img_shape)
mean_img = cv2.accumulate(temp_img.astype(dtype=np.float32), mean_img)
if file_count % 10000 == 0:
print(f"\tProcessed {file_count:0d} images.")
# divide by n_images
mean_img = np.divide(mean_img, file_count + 1)
return mean_img
def ComputeMean(dir_path, mean_file_write_to):
#resize 尺寸
protosize = (48, 48)
#可以限定生成均值图像使用的图像数量
mean_count = 100
i = 0
totalMean = np.zeros((protosize[0], protosize[1], 3), dtype=np.float)
accedImage = np.zeros((protosize[0], protosize[1], 3), dtype=np.float)
with open(dir_path, "r") as f:
reader = csv.reader(f)
for row in reader:
if (i < mean_count):
img_path = row[0]
img_data = cv2.imread(img_path)
img_resized = cv2.resize(img_data,
protosize,
interpolation=cv2.INTER_LINEAR)
cv2.accumulate(img_resized, accedImage)
#累计1000次计算一次均值速度会快一些，如果图像太多汇总起来再计算可能会溢出。
if (i % 10 == 0 and i > 0):
accedImage = accedImage / float(mean_count)
cv2.accumulate(accedImage, totalMean)
accedImage = np.zeros((protosize[0], protosize[1], 3),
dtype=np.float)
print("processed: " + str(i))
if i == mean_count:
break
i = i + 1
accedImage = accedImage / float(mean_count)
cv2.accumulate(accedImage, totalMean)
#for RGB image
# totalMean=totalMean.transpose((2, 0, 1))
# 存储为binaryproto
blob = caffe_pb2.BlobProto()
blob.channels = 3
blob.height = protosize[0]
blob.width = protosize[1]
blob.num = 1
blob.data.extend(totalMean.astype(float).flat)
binaryproto_file = open(mean_file_write_to, 'wb')
binaryproto_file.write(blob.SerializeToString())
binaryproto_file.close()
from __future__ import division
import cv2
import numpy as np
from sys import argv
vid = cv2.VideoCapture(argv[1])
total_frames = vid.get(7)
avg = np.zeros([vid.get(4), vid.get(3), 3])
while vid.grab():
flag, frame = vid.retrieve()
cv2.accumulate(frame, avg)
# every 30 seconds
if vid.get(1) % (60 * 30) == 0:
print vid.get(1), "frames"
hsv = cv2.convertScaleAbs(avg / vid.get(1))
# extract saturation channel
hsv = cv2.cvtColor(hsv, cv2.COLOR_RGB2HSV)[:, :, 1]
cv2.imshow("b", hsv)
cv2.waitKey(0)
cv2.destroyAllWindows()
# threshold for greys
_, bin = cv2.threshold(hsv, 114, 0xFF, cv2.THRESH_TOZERO)
_, bin = cv2.threshold(bin, 142, 0xFF, cv2.THRESH_BINARY_INV)
cv2.imshow("b", bin)
ct=0
##################################################
#
# Read raw frame
#
##################################################
print "Read raw video..."
while(1):
ret ,frame = vidcap.read()
if ret == True :
image[count] =frame
image_rect[count] =frame
if root.findall('spot')!=[]:
if count>istart and count<iend:
average_spot=cv2.accumulate(image[count],average_spot)
count+=1
if root.findall('preview')!=[]:
if prevraw=='yes':
cv2.imshow('Raw video',frame)
k = cv2.waitKey(1) & 0xff
else:
break
print "Done"
##################################################
#
# Spot option (camera imperfection removal)
#
##################################################
# Start webcam
webcam = cv2.VideoCapture()
webcam.open(1)
# Init image
dummy, final_image = webcam.read()
final_image = np.zeros( final_image.shape, dtype = np.float64)
while True:
dummy, new_image = webcam.read()
dummy, mask = cv2.threshold(new_image, 125, 255, cv2.THRESH_BINARY)
mask = mask[:, :, 0] | mask[:,:,1] | mask[:, :, 2]
#cv2.accumulateWeighted(new_image, final_image, 0.5)
cv2.accumulate(new_image, final_image, mask)
cv2.imshow("Result", final_image.astype(np.uint8))
k = cv2.waitKey(30) & 0xFF
if k == ord('q'):
break
elif k == ord('r'):
# Reset image:
dummy, final_image = webcam.read()
final_image = np.zeros( final_image.shape, dtype = np.float64)
cv2.destroyAllWindows()
cv2.imwrite(output_file, final_image)
def blur_Radial(source, size, xm, ym, low_high=(-5, 5), path=None, plot=None):
filter_V = np.zeros((size, size))
filter_V[:, int((size - 1) / 2)] = np.ones(size)
filter_V = filter_V / size
high_ = low_high[1]
low_ = low_high[0]
sm_dims = high_ - low_ + 1
sm = np.zeros((sm_dims, sm_dims))
image_RGB = cv2.cvtColor(source, cv2.COLOR_BGR2RGB)
sum = sumsq = None
cnt = 0
for dx in range(low_, high_ + 1):
for dy in range(low_, high_ + 1):
polar_image = linear_2_Polar(source, xm + dx, ym + dy)
polar_rad = cv2.filter2D(polar_image, -1, filter_V)
if sum is None:
sum = np.zeros(polar_rad.shape, np.float32)
if sumsq is None:
sumsq = np.zeros(polar_rad.shape, np.float32)
dx2 = cv2.accumulate(polar_rad, sum)
dy2 = cv2.accumulateSquare(polar_rad, sumsq)
cnt = cnt + 1
xx = dx + high_
yy = dy + high_
if not (path is None) and Path(path).exists():
fname = path + 'polar_rad_%s_%s.png' % (xx, yy)
cv2.imwrite(fname, polar_rad)
polar_rad = polar_2_Linear(source, polar_rad, xm + dx, ym + dy)
if dx == 0 and dy == 0:
polar_rad_0_0 = polar_rad
sm[dx + high_, dy + high_] = similarity(source, polar_rad)
sumsq = cv2.multiply(sumsq, cnt)
var_image = cv2.multiply(sum, sum)
var_image = cv2.subtract(sumsq, var_image)
var_image = cv2.divide(var_image, cnt * (cnt - 1))
c1, c2, c3 = cv2.split(var_image)
cc = (c1 + c2 + c3) / 3
ydata = cv2.reduce(cc, 0, cv2.REDUCE_SUM, dtype=-1).flatten()
idx = 0
for yd in ydata:
print('%d %d' % (idx, yd))
idx = idx + 1
xdata = np.arange(len(ydata))
resd = find_inflections(xdata, ydata)
result = resd['inflection']
first_valley = resd['xvalleyes']
pupil_radii = (first_valley[0] + first_valley[1]) / 2.0
if plot:
f1, ax1 = plt.subplots(1)
ax1.set_aspect('equal')
ax1.imshow(image_RGB)
ax1.set_title("Pupil Results")
c = patches.Circle((xm, ym),
pupil_radii,
color='red',
linewidth=2,
fill=False)
ax1.add_patch(c)
plt.show()
print(resd)
mode = cv2.RETR_EXTERNAL
method = cv2.CHAIN_APPROX_SIMPLE
#2
t = 0
while True:
ret, frame = cap.read()
if not ret:
break
t += 1
print("t = ", t)
blur = cv2.GaussianBlur(frame, (5, 5), 0.0)
#2-1
if t < 50:
cv2.accumulate(blur, acc_bgr)
continue
elif t == 50:
bkg_bgr = acc_bgr / t
#2-2: t >= 50
## diff_bgr = cv2.absdiff(np.float32(blur), bkg_bgr).astype(np.uint8)
diff_bgr = np.uint8(cv2.absdiff(np.float32(blur), bkg_bgr))
db, dg, dr = cv2.split(diff_bgr)
ret, bb = cv2.threshold(db, TH, 255, cv2.THRESH_BINARY)
ret, bg = cv2.threshold(dg, TH, 255, cv2.THRESH_BINARY)
ret, br = cv2.threshold(dr, TH, 255, cv2.THRESH_BINARY)
bImage = cv2.bitwise_or(bb, bg)
bImage = cv2.bitwise_or(br, bImage)
bImage = cv2.erode(bImage, None, 5)
bImage = cv2.dilate(bImage, None, 5)
bImage = cv2.erode(bImage, None, 7)
print e
####
while True:
#camera.start_preview()
raw=PiRGBArray(camera,size=(640,480))
stream = camera.capture_continuous(raw,format="bgr",use_video_port=True)
#print("[INFO]sampling frames from picamera module")
#fps=FPS().start()
for(i,f) in enumerate(stream):
frame = f.array
if ac_count==0:
ac=frame
continue
elif ac_count < 5:
ac=cv2.accumulate(ac,frame)
continue
elif ac_count == 5:
ac_count =0
img=frame.copy()
frame = frame[crop_y:crop_y+crop_h,crop_x:crop_x+crop_w]
# Step 1 : grayscale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Step 2 : medianBlur
median = cv2.medianBlur(gray,7)
# Step 3 : find lastframe
if counter == 0:
lastframe = median
counter = 1
break
cv2.namedWindow("input")
cv2.namedWindow("sig2")
cv2.namedWindow("detect")
BGsample = 20 # number of frames to gather BG samples from at start of capture
success, img = cap.read()
width = cap.get(3)
height = cap.get(4)
if success:
acc = np.zeros((height, width), np.float32) # 32 bit accumulator
sqacc = np.zeros((height, width), np.float32) # 32 bit accumulator
for i in range(20): a = cap.read() # dummy to warm up sensor
# gather BG samples
for i in range(BGsample):
success, img = cap.read()
frame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.accumulate(frame, acc)
cv2.accumulateSquare(frame, sqacc)
#
M = acc/float(BGsample)
sqaccM = sqacc/float(BGsample)
M2 = M*M
sig2 = sqaccM-M2
# have BG samples now
# calculate upper and lower bounds of detection window around mean.
# coerce into 8bit image space for cv2.inRange compare
detectmin = cv2.convertScaleAbs(M-sig2)
detectmax = cv2.convertScaleAbs(M+sig2)
# start FG detection
key = -1
while(key < 0):
success, img = cap.read()
int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)))
acc_gray = np.zeros(shape=(height, width), dtype=np.float32)
acc_bgr = np.zeros(shape=(height, width, 3), dtype=np.float32)
t = 0
#2
while True:
ret, frame = cap.read()
if not ret:
break
t += 1
print('t =', t)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cv2.accumulate(gray, acc_gray)
avg_gray = acc_gray / t
dst_gray = cv2.convertScaleAbs(avg_gray)
cv2.accumulate(frame, acc_bgr)
avg_bgr = acc_bgr / t
dst_bgr = cv2.convertScaleAbs(avg_bgr)
cv2.imshow('frame', frame)
cv2.imshow('dst_gray', dst_gray)
cv2.imshow('dst_bgr', dst_bgr)
key = cv2.waitKey(20)
if key == 27:
break
#3
if cap.isOpened(): cap.release()
ref = ref[0:sig_n - 1]
#ref = np.array([-1.0, 1.0, -6.0, 6.0, -1.0, 1.0, -6.0, 6.0, -1.0, 1.0, -5.0, 4.0, 0.0,1.0, -6.0, 6.0, -1.0, 1.0, -6.0, 6.0, -1.0, 1.0, -5.0, 4.0, 0.0,1.0, -6.0, 6.0, -1.0, 1.0, -6.0, 6.0, -1.0, 1.0, -5.0, 4.0, 0.0])
#ref = ref * 3
f = np.fft.fft(ref)
fshift = np.fft.fftshift(f)
y1 = (np.abs(fshift))
Ar = -y1.conjugate()
while (d <= sig_n):
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
grad = np.int8(gray - pgray) # change the intensity type to iny8
if (d != 0):
arr.append(grad)
accn = np.float64(grad)
cv2.accumulate(accn, acc)
cv2.convertScaleAbs(acc, accu)
pgray = gray
d += 1
if (d == sig_n):
for k in range(d - 1):
sr[k, :, :] = arr[k]
if (d == sig_n):
for v in range(rows):
for u in range(cols):
if (accu.item(v, u)) != 0:
for k in range(d - 1):
sg[k] = sr[k][v][u]
# if u==347 and v==615:
# print sg
def bg_average(average, images,count):
cv2.accumulate(images, average)
average = average / count
average = np.uint8(average)
return average
def detector(v_name, n, th):
cap = cv2.VideoCapture(v_name)
ret, frame = cap.read()
rows, cols = frame.shape[:2]
# ref_image = frame[:,:,1] # reference is the first frame
ref_image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = np.zeros((rows, cols), np.uint8)
pgray = np.zeros((rows, cols), np.uint8)
grad = np.zeros((rows, cols), np.int8)
acc = np.zeros((rows, cols), np.float64)
accu = np.zeros((rows, cols), np.uint8)
dmax = n # number of processed frames
dst = np.zeros((rows, cols, 3), np.uint8)
sr = np.zeros((dmax, rows, cols))
# dst[:] = 255
d = 0
arr = []
sg = [None] * dmax
# reference signal
ref = np.array(
[
5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0,
0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0,
0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0,
-5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0,
-5.0, 5.0, 0.0, 0.0, -5.0, 5.0, 0.0, 0.0, -5.0
]
) # 2 or 3 is mainly good for straight v and h lines and still good for slopes
ref = ref[0:dmax]
# ref=np.array([ 0.0, 3.0, 0.0, -3, 0.0, 3.0,0, -3.0,0.0,3.0, 0, -3.0, 0.0, 3.0, 0, -3.0, 0.0, 3.0, 0,-3.0 ])#4 corner model good for corner and sloped lines or curves
f = np.fft.fft(ref)
fshift = np.fft.fftshift(f)
y1 = (np.abs(fshift))
Ar = -y1.conjugate()
af = scipy.fft(ref)
pgray = ref_image
f = open("signal4p.txt", "w")
###############
# start to process a set of oscillation frames
while (d <= dmax):
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# gray = frame[:,:,1]
grad = np.int8(gray - pgray)
# align
# shift, error, diffphase = register_translation(gray, ref_image, 100) #measure shift
# if (d!=0) :
# shift=(-shift[0],-shift[1])
# offset_image = fourier_shift(np.fft.fft2(grad), shift)
# grad1 = np.fft.ifft2(offset_image)
# grad2 = np.real(grad1) #np.abs(grad1)
arr.append(grad) # append(np.real(grad1))
# accn= np.float64(grad2)
cv2.accumulate(np.uint8(grad),
acc) # (grad2,acc) # accumulated gradients
cv2.convertScaleAbs(acc, accu) # get the unsigned acc
pgray = gray
'''newimg = cv2.resize(accu, (int(cols / 2), int(rows / 2)))
cv2.imshow('Image', newimg)
if cv2.waitKey(10) & 0xFF == ord('q'):
break'''
d += 1
###########
### load sr as 3d array
for k in range(dmax):
sr[k, :, :] = arr[k]
for v in range(rows):
for u in range(cols):
if (accu.item(v,
u)) != 0: # if accumulated pixel value is non zero
for k in range(dmax):
sg[k] = sr[k][v][u]
if np.std(sg) > 1.5:
f.write('%d %d \n' % (u, v))
for l in range(dmax):
f.write('%d\n' % sg[l])
f1 = np.fft.fft(sg)
fshift1 = np.fft.fftshift(f1)
y2 = (np.abs(fshift1))
cc = np.abs(np.corrcoef(y2, y1))
bf = scipy.fft(sg)
c = scipy.ifft(af * scipy.conj(bf))
ps = np.argmax(abs(c))
# get orientation of line and color code it
ps = ps % 4 # phase shift over integer no of cycles
if cc[1][0] > th:
if ps == 0:
dst.itemset((v, u, 0), 255)
dst.itemset((v, u, 1), 255)
dst.itemset((v, u, 2), 255)
if ps == 1:
dst.itemset((v, u, 0), 255)
dst.itemset((v, u, 1), 255)
dst.itemset((v, u, 2), 255)
if ps == 2:
dst.itemset((v, u, 0), 255)
dst.itemset((v, u, 1), 255)
dst.itemset((v, u, 2), 255)
if ps == 3:
dst.itemset((v, u, 0), 255)
dst.itemset((v, u, 1), 255)
dst.itemset((v, u, 2), 255)
cv2.imwrite("res_m.jpg", dst)
t2 = time()
print
'time is %f' % (t2 - t0)
cap.release()
f.close()
cv2.destroyAllWindows()
return dst
numberOfIterations = 1
print("Number of loop iterations: " + str(numberOfIterations))
dstSW = np.zeros((height, width), np.float)
xFimgY1 = mem_manager.cma_array(
(height, width), np.uint8) #allocated physically contiguous numpy array
xFimgY1[:] = imgY1[:] # copy source data
xFdst = mem_manager.cma_array(
(height, width), np.uint16) #allocated physically contiguous numpy array
print("Start SW loop")
startSW = time.time()
for i in range(numberOfIterations):
cv2.accumulate(imgY1, dst=dstSW) #accumulate on ARM
stopSW = time.time()
print("SW loop finished")
print("Start HW loop")
startPL = time.time()
for i in range(numberOfIterations):
xv2.accumulate(
xFimgY1, dst=xFdst
) #accumulate offloaded to PL, working on physically continuous numpy arrays
stopPL = time.time()
print("HW loop finished")
print("SW frames per second: ", ((numberOfIterations) / (stopSW - startSW)))
print("PL frames per second: ", ((numberOfIterations) / (stopPL - startPL)))
