def background_subtraction(background_image, foreground_image, device, debug=None):
"""Creates a binary image from a background subtraction of the foreground using cv2.BackgroundSubtractorMOG().
The binary image returned is a mask that should contain mostly foreground pixels.
The background image should be the same background as the foreground image except not containing the object
of interest.
Images must be of the same size and type.
If not, larger image will be taken and downsampled to smaller image size.
If they are of different types, an error will occur.
Inputs:
background_image = img object, RGB or binary/grayscale/single-channel
foreground_image = img object, RGB or binary/grayscale/single-channel
device = device number. Used to count steps in the pipeline
debug = None, print, or plot. Print = save to file, Plot = print to screen.
Returns:
device = device number
fgmask = background subtracted foreground image (mask)
:param background_image: numpy array
:param foreground_image: numpy array
:param device: int
:param debug: str
:return device: int
:return fgmask: numpy array
"""
device += 1
# Copying images to make sure not alter originals
bg_img = np.copy(background_image)
fg_img = np.copy(foreground_image)
# Checking if images need to be resized or error raised
if bg_img.shape != fg_img.shape:
# If both images are not 3 channel or single channel then raise error.
if len(bg_img.shape) != len(fg_img.shape):
fatal_error("Images must both be single-channel/grayscale/binary or RGB")
# Forcibly resizing largest image to smallest image
print("WARNING: Images are not of same size.\nResizing")
if bg_img.shape > fg_img.shape:
width, height = fg_img.shape[1], fg_img.shape[0]
bg_img = cv2.resize(bg_img, (width, height), interpolation=cv2.INTER_AREA)
else:
width, height = bg_img.shape[1], bg_img.shape[0]
fg_img = cv2.resize(fg_img, (width, height), interpolation=cv2.INTER_AREA)
# Instantiating the background subtractor, for a single history no default parameters need to be changed.
if cv2.__version__[0] == '2':
bgsub = cv2.BackgroundSubtractorMOG()
else:
bgsub = cv2.createBackgroundSubtractorMOG2()
# Applying the background image to the background subtractor first.
# Anything added after is subtracted from the previous iterations.
fgmask = bgsub.apply(bg_img)
# Applying the foreground image to the background subtractor (therefore removing the background)
fgmask = bgsub.apply(fg_img)
# Debug options
if debug == "print":
print_image(fgmask, "{0}_background_subtraction.png".format(device))
elif debug == "plot":
plot_image(fgmask, cmap="gray")
return device, fgmask
#混合高斯建模
import numpy as np
import cv2
cap = cv2.VideoCapture('viptraffic.avi')
fourcc = cv2.cv.FOURCC(*'XVID')
out = cv2.VideoWriter('output1.avi', fourcc, 20.0, (160, 120), 0) #写视频的参数设置
fgbg = cv2.BackgroundSubtractorMOG(200, 5, 0.7) #创建一个背景对象
cv2.namedWindow('img', cv2.WINDOW_NORMAL)
cv2.namedWindow('fgmask', cv2.WINDOW_NORMAL) #创建两个窗口
i = 0
while (1):
ret, frame = cap.read() #读入视频帧
i = i + 1
print i #统计帧数
if ret: #读入正确则继续
fgmask = fgbg.apply(frame, learningRate=0.02) #计算前景掩模
out.write(fgmask) #写入视频
cv2.imshow('img', frame)
cv2.imshow('fgmask', fgmask) #显示结果
k = cv2.waitKey(1000)
if k == 27:
break
else:
break
cap.release()
cv2.destroyAllWindows()
br = CvBridge() # Create a black image, a window
#--------------------------------------------------------------------------------------#
def detect_and_draw(imgmsg):
global x, y
img = br.imgmsg_to_cv2(imgmsg, desired_encoding="passthrough")
img = img[:, :, 0:3]
fgmask = fgbg.apply(img)
cv2.imshow('rgb', img)
#cv2.imshow('frame',fgmask)
img1_bg = cv2.bitwise_and(img, img, mask=fgmask)
img_obj = img.copy()
for i in range(len(x)):
print i
img_obj[y[i], x[i], :] = [255, 0, 0]
cv2.imshow('object', img_obj)
cv2.imshow('masked', img1_bg)
k = cv2.waitKey(1) & 0xff
#--------------------------------------------------------------------------------------#
fgbg = cv2.BackgroundSubtractorMOG()
rospy.init_node('object_detection')
LH_image_topic = rospy.resolve_name("/cameras/left_hand_camera/image")
rospy.Subscriber(LH_image_topic, sensor_msgs.msg.Image, detect_and_draw)
rospy.spin()
def track_ball_3(video):
"""
As track_ball_1, but for ball_3.mov.
Requires going through the video once to find the size of the moving
object, then again to track its location
"""
result = []
num_frames = 0
fgbg = cv2.BackgroundSubtractorMOG()
x, y, w, h = 0, 0, 0, 0
avg_w, avg_h = 0, 0
ret, frame = video.read()
while ret is True:
num_frames = num_frames + 1
sub = fgbg.apply(frame)
kernel = numpy.ones((5, 5), numpy.uint8)
dilation = cv2.dilate(sub, kernel, iterations=1)
ret, thresh = cv2.threshold(dilation, 127, 255, 0)
# contours is a list of all the contours in the image
contours, _ = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
if (contours):
x, y, w, h = cv2.boundingRect(contours[0])
avg_w = avg_w + w
avg_h = avg_h + h
ret, frame = video.read()
avg_w = avg_w / num_frames
avg_h = avg_h / num_frames
# Reset the video
video.set(cv2.cv.CV_CAP_PROP_POS_AVI_RATIO, 0)
# take first frame of the video
ret, frame = video.read()
# setup initial location of window to track an object of the
# size determined previously
track_window = (avg_w, avg_w, avg_h, avg_h)
x, y, w, h = track_window
# set up the ROI for tracking
roi = frame[y:y + h, x:x + w]
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, numpy.array((0., 60., 32.)),
numpy.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# setup the termination criteria,
# either 10 iteration or move by atleast 1 pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
while ret is True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
# apply meanshift to get the new location
ret, track_window = cv2.meanShift(dst, track_window, term_crit)
# draw it on image
x, y, w, h = track_window
result.append((x, y, x + w, y + h))
ret, frame = video.read()
return result
def process_frames(source,
display=False,
clear_iters=1,
blur_kernel=(5, 5),
max_frames=-1):
"""Reads a video from source (a file or a camera) and performs preprocessing and transformation into
a vector representation for each frame. The preprocessing consists of blurring, eroding, dilating, extracting
the contour, then transforming it into a vector representation of its chain code form. See function get_chain_vector.
source : Video source. File path or 0 for camera.
display : Show contour and print progress
clear_iters : How many iterations of erosion od dilation to perform
blur_kernel : Kernel for Gaussian blur
max_frames : Number of frames to read. -1 for all. Needs to be used with camera to prevent infinite filming.
returns : Vector representations of motion in frames in video
"""
kernel = np.ones((3, 3), np.uint8)
cap = cv2.VideoCapture(source)
fgbg = cv2.BackgroundSubtractorMOG(60 * 30, 256, 0.9, 0.01)
frames = []
ret, frame = cap.read()
if not ret:
return []
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(frame, blur_kernel, 0)
erosion = cv2.erode(blur, kernel, iterations=clear_iters)
dilatation = cv2.dilate(erosion, kernel, iterations=clear_iters)
avg = np.float32(dilatation)
frame_cnt = 0
while (1):
ret, frame = cap.read()
if not ret: break
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(frame, (5, 5), 0)
erosion = cv2.erode(blur, kernel, iterations=clear_iters)
dilatation = cv2.dilate(erosion, kernel, iterations=clear_iters)
cv2.accumulateWeighted(dilatation, avg, 0.025) # HERE
frames.append(dilatation)
frame_cnt += 1
if max_frames != -1 and frame_cnt >= max_frames:
break
cap.release()
average = cv2.convertScaleAbs(avg)
fgbg.apply(average)
chains = []
for frame in frames:
img = fgbg.apply(frame)
img1 = copy.deepcopy(img)
contours, hierarchy = cv2.findContours(img1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)
chains.append(get_chain_vector(contours))
if display == True and contours:
cv2.drawContours(img1, contours, -1, (255, 0, 0), 1)
cv2.imshow('Silueta', img1)
cv2.waitKey(1)
cv2.destroyAllWindows()
return [frame for frame in chains if frame.any()]
def batch_identify_fish(dir, motion_detection_dir):
"""Input as video, return processed video with identified fish"""
videofile = os.path.join(dir, 'forPTV.mp4')
camera = cv2.VideoCapture(videofile)
if camera.isOpened():
pass
else:
print "Converting MP4 file..."
os.system('ffmpeg -i %s -c:v copy %s_Converted.mp4' %
(videofile, videofile[:-4]))
camera = cv2.VideoCapture('%s_Converted.MP4' % videofile[:-4])
fps = camera.get(cv2.cv.CV_CAP_PROP_FPS)
history = np.int(fps / 2)
# creating background subtraction object
fgbg = cv2.BackgroundSubtractorMOG() # It works for opencv 2.4
# creating video writing object, outside of the loop
size = (int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)),
int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)) * 2)
fourcc = cv2.cv.FOURCC('8', 'B', 'P', 'S') #works, large
# output = cv2.VideoWriter(os.path.join(data_dir, 'rawVideo_identifiedFish.avi'), fourcc, fps, size, True)
# size for individual video
size_1 = (int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)),
int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)))
# out_fish_only = cv2.VideoWriter(os.path.join(data_dir,'fishOnly.avi'), fourcc, fps, size_1, True)
# size for individual video, background subtraction results
fgbg_results = cv2.VideoWriter(
os.path.join(motion_detection_dir, 'fgbg_MOG_results.avi'), fourcc,
fps, size_1, True)
print "~~~ identifying fish from raw video..."
#### starting the loop
frame_nb = 0
while True:
print frame_nb
grabbed, frame = camera.read()
if not grabbed:
break
frame_nb += 1
#### bluring before binarizing can help remove small noise
# blurred = cv2.bilateralFilter(clean_frame, 5, 15,15)
# blurred_1 = cv2.GaussianBlur(blurred, (3, 3), 0)
# return <type 'numpy.ndarray'>, 1-channel pics
# fgmask = fgbg.apply(frame, learningRate=0.01)
fgmask = fgbg.apply(frame)
# print np.shape(fgmask)
fgmask_3d = cv2.cvtColor(fgmask, cv2.COLOR_GRAY2RGB)
# print np.shape(fgmask_3d)
'''
#### removing noise, optional
kernel = np.ones((3,3), np.uint8)
erosion = cv2.erode(fgmask, kernel)
dilation = cv2.dilate(erosion, kernel)
ret, thresh = cv2.threshold(dilation, 200, 255, 0)
contours, hierarchy = cv2.findContours(thresh,1,2)
c_x, c_y = find_fish(dilation, contours, remove_noise=True)
centroids.append([c_x, c_y])
# centroids_deque.appendleft((c_x, c_y))
# print "the chanel of fgmask is: " + str(np.shape(fgmask)[-1])
#### converting 1 channel binary images to 3 channel images, for stacking them together
identified_fish = cv2.cvtColor(dilation, cv2.COLOR_GRAY2RGB)
# print np.shape(fgmask)
cv2.imshow('frame', dilation)
#### using cv2.inpaint to blend the fish into the background
# blended = cv2.inpaint(frame, dilation, 3, cv2.INPAINT_TELEA)
# print "the chanel of blended is: " + str(np.shape(blended)[-1])
#### showing
twoV = np.vstack((frame, identified_fish))
#### adding name on different frames, Bottom-left corner of the text string in the image
font = cv2.FONT_HERSHEY_SIMPLEX
width = np.shape(frame)[0]
hight = np.shape(frame)[1]
cv2.putText(twoV, 'Original Video', (int(width/2-80),int(hight/15)), font, 0.7,(0,0,255),2)
cv2.putText(twoV, 'Identified Fish', (int(width/2-80),int(hight/9)+int(hight/2)), font, 0.7,(0,0,255),2)
'''
# cv2.putText(threeV, 'Fish blended with Background', (int(width/2-80),int(hight/6)+int(hight)), font, 0.7,(0,0,255),2)
# cv2.putText(blended, 'Fish blended with Background',(int(width/2-80),int(hight/15)), font, 0.7,(0,0,255),2)
# cv2.putText(blended, '(Preprocessing for Streams)', (int(width/2-80),int(hight/15)+20), font, 0.7,(0,0,255),1)
#### saving videos to the video recorder
# output.write(twoV)
# out_fish_only.write(identified_fish)
fgbg_results.write(fgmask_3d)
# cv2.imshow('Feedin-Tracking', twoV)
# cv2.imshow('Identified Fish)', identified_fish)
# cv2.imshow('BgFg', fgmask_3d)
#### release the video capture and video output after work.
camera.release()
# output.release()
# out_fish_only.release()
fgbg_results.release()
cv2.destroyAllWindows()
print "Done!"
def get_scenes(cap, tail=2):
last_frame = None
i = 0
fgbg = cv2.BackgroundSubtractorMOG()
exp_avrg = 0
scenes = []
avrgs = []
diffs = []
max_bspeed = 0
count = 0
max_brightness = 0
avrg_brightness = 0
while (cap.isOpened()):
ret, frame = cap.read()
if ret:
if i == tail:
fgbg = cv2.BackgroundSubtractorMOG()
i = 0
fgmask = fgbg.apply(frame)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
brightness = frame.mean()
width, height = frame.shape
if i > 0 and i < tail:
w, h = fgmask.shape
diff = np.count_nonzero(fgmask) / (1.0 * w * h)
if diff > exp_avrg:
avrg_brightness /= 1.0 * count
scenes.append({
"end_frame":
cap.get(cv2.cv.CV_CAP_PROP_POS_FRAMES),
"max_bspeed":
max_bspeed,
"avrg_bspeed":
exp_avrg,
"max_brightness":
max_brightness,
"avrg_brightness":
avrg_brightness
})
exp_avrg = _alpha * diff + (1 - _alpha) * exp_avrg
max_bspeed = 0
max_brightness = 0
max_bspeed = max(diff, max_bspeed)
avrgs.append(exp_avrg)
diffs.append(diff)
count += 1
max_brightness = max(brightness, max_brightness)
avrg_brightness += brightness
i += 1
if cap.get(cv2.cv.CV_CAP_PROP_POS_FRAMES) == cap.get(
cv2.cv.CV_CAP_PROP_FRAME_COUNT):
break
# print scenes
fr_start = 0
ret_scenes = []
for j in range(len(scenes)):
scene = scenes[j]
fr_end = scene["end_frame"]
duration = (fr_end - fr_start) / cap.get(cv2.cv.CV_CAP_PROP_FPS)
if duration > _min_scene_length and duration < _max_scene_length:
scenes[j]["start"] = fr_start / cap.get(cv2.cv.CV_CAP_PROP_FPS)
scenes[j]["end"] = fr_end / cap.get(cv2.cv.CV_CAP_PROP_FPS)
scenes[j]["duration"] = duration
scenes[j]["position"] = fr_start / \
cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)
ret_scenes.append(scenes[j])
fr_start = fr_end
return ret_scenes
class Ui_MainWindow(object):
source = None
player = None
title = None
score = None
level = 20
scoreLine = {}
notes = None
listindex = 0
frame = None
vwidth = 640
vheight = 480
totaltime = 0
lrbnd = 70
ubnd = 100
fgbg = cv2.BackgroundSubtractorMOG()
transition = 'mid'
ctransition = None
minsize = 10
font = cv2.FONT_HERSHEY_SIMPLEX
correct = 0
leftval = 0
midval = 0
rightval = 0
upval = 0
lenl = vheight * lrbnd
lenm = (vheight - ubnd) * (vwidth - (2 * lrbnd))
lenr = vheight * lrbnd
lenu = (vwidth - (2 * lrbnd)) * ubnd
t_minus = cv2.cvtColor(np.zeros((vheight, vwidth, 3), np.uint8),
cv2.COLOR_RGB2GRAY)
t = cv2.cvtColor(np.zeros((vheight, vwidth, 3), np.uint8),
cv2.COLOR_RGB2GRAY)
t_plus = cv2.cvtColor(np.zeros((vheight, vwidth, 3), np.uint8),
cv2.COLOR_RGB2GRAY)
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(820, 635)
MainWindow.setMinimumSize(820, 635)
MainWindow.setMaximumSize(820, 635)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.lineEdit = QtGui.QTextEdit(self.centralwidget)
self.lineEdit.setGeometry(QtCore.QRect(10, 475, 800, 105))
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.lineEdit.setReadOnly(True)
redir = RedirectText(self.lineEdit)
sys.stdout = redir
self.lineEdit.append(
u'Microsoft Imagine Cup 2017 - ARshaker에 오신 것을 환영합니다.')
self.lineEdit.append(u'음악 파일이나 기 생성된 악보 파일(*.jhw)을 열어주세요!')
self.lineEdit.append(u'JHW=김주현(JH)+황혜원(HW) 제작')
self.listWidget = QtGui.QListWidget(self.centralwidget)
self.listWidget.setGeometry(QtCore.QRect(650, 5, 160, 465))
self.listWidget.setObjectName(_fromUtf8("listWidget"))
self.seekSlider = Phonon.SeekSlider(self.centralwidget)
self.seekSlider.setGeometry(QtCore.QRect(220, 6, 241, 22))
self.seekSlider.setObjectName(_fromUtf8("seekSlider"))
paletteb = QtGui.QPalette()
paletteb.setBrush(QtGui.QPalette.Light, QtCore.Qt.black)
paletteg = QtGui.QPalette()
paletteg.setBrush(QtGui.QPalette.Light, QtCore.Qt.green)
palettegl = QtGui.QPalette()
palettegl.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkYellow)
paletter = QtGui.QPalette()
paletter.setBrush(QtGui.QPalette.Light, QtCore.Qt.red)
palettem = QtGui.QPalette()
palettem.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkMagenta)
palettebl = QtGui.QPalette()
palettebl.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkBlue)
palettebb = QtGui.QPalette()
palettebb.setBrush(QtGui.QPalette.Light, QtCore.Qt.blue)
palettebc = QtGui.QPalette()
palettebc.setBrush(QtGui.QPalette.Light, QtCore.Qt.cyan)
self.lcdNumber = QtGui.QLCDNumber(self.centralwidget)
self.lcdNumber.setPalette(paletteb)
self.lcdNumber.setGeometry(QtCore.QRect(580, 5, 64, 23))
self.lcdNumber.setObjectName(_fromUtf8("lcdNumber"))
self.lcdNumber.display("00:00")
self.lcdr = QtGui.QLCDNumber(self.centralwidget)
self.lcdr.setPalette(palettegl)
self.lcdr.setGeometry(QtCore.QRect(15, 420, 80, 23))
self.lcdr.setObjectName(_fromUtf8("lcdr"))
self.lcdr.display("00:00")
self.rlab = QtGui.QLabel(self.centralwidget)
self.rlab.setText(u'남은 시간')
self.rlab.setGeometry(QtCore.QRect(23, 445, 100, 22))
self.lcda = QtGui.QLCDNumber(self.centralwidget)
self.lcda.setPalette(paletteb)
self.lcda.setGeometry(QtCore.QRect(110, 420, 80, 23))
self.lcda.setObjectName(_fromUtf8("lcdAccu"))
self.lcda.display("00000")
self.alab = QtGui.QLabel(self.centralwidget)
self.alab.setText(u'현재 비트')
self.alab.setGeometry(QtCore.QRect(118, 445, 100, 22))
self.lcdo = QtGui.QLCDNumber(self.centralwidget)
self.lcdo.setPalette(palettebb)
self.lcdo.setGeometry(QtCore.QRect(205, 420, 80, 23))
self.lcdo.setObjectName(_fromUtf8("lcdCorrect"))
self.lcdo.display("00000")
self.olab = QtGui.QLabel(self.centralwidget)
self.olab.setText(u'맞은 비트')
self.olab.setGeometry(QtCore.QRect(213, 445, 100, 22))
self.lcdx = QtGui.QLCDNumber(self.centralwidget)
self.lcdx.setPalette(palettem)
self.lcdx.setGeometry(QtCore.QRect(300, 420, 80, 23))
self.lcdx.setObjectName(_fromUtf8("lcdWrong"))
self.lcdx.display("00000")
self.xlab = QtGui.QLabel(self.centralwidget)
self.xlab.setText(u'틀린 비트')
self.xlab.setGeometry(QtCore.QRect(308, 445, 100, 22))
self.lcdl = QtGui.QLCDNumber(self.centralwidget)
self.lcdl.setPalette(paletteg)
self.lcdl.setGeometry(QtCore.QRect(395, 420, 80, 23))
self.lcdl.setObjectName(_fromUtf8("lcdLeft"))
self.lcdl.display("00000")
self.llab = QtGui.QLabel(self.centralwidget)
self.llab.setText(u'남은 비트')
self.llab.setGeometry(QtCore.QRect(403, 445, 100, 22))
self.lcdpg = QtGui.QLCDNumber(self.centralwidget)
self.lcdpg.setPalette(palettebc)
self.lcdpg.setGeometry(QtCore.QRect(490, 420, 70, 23))
self.lcdpg.setObjectName(_fromUtf8("lcdProgress"))
self.lcdpg.display("00000")
self.pglab = QtGui.QLabel(self.centralwidget)
self.pglab.setText(u'진행률(%)')
self.pglab.setGeometry(QtCore.QRect(491, 445, 100, 22))
self.lcdg = QtGui.QLCDNumber(self.centralwidget)
self.lcdg.setPalette(paletter)
self.lcdg.setGeometry(QtCore.QRect(572, 420, 70, 23))
self.lcdg.setObjectName(_fromUtf8("lcdPercent"))
self.lcdg.display("00000")
self.glab = QtGui.QLabel(self.centralwidget)
self.glab.setText(u'정확도(%)')
self.glab.setGeometry(QtCore.QRect(573, 445, 100, 22))
self.lrlab = QtGui.QLabel(self.centralwidget)
self.lrlab.setText(u'좌,우(L,R)크기')
self.lrlab.setGeometry(QtCore.QRect(13, 380, 100, 22))
self.lrsl = QtGui.QSlider(QtCore.Qt.Horizontal, self.centralwidget)
self.lrsl.setGeometry(QtCore.QRect(117, 380, 120, 22))
self.lrsl.setMinimum(30)
self.lrsl.setMaximum(200)
self.lrsl.setValue(30)
self.lrsl.setObjectName(_fromUtf8("lrsl"))
self.lrsl.valueChanged.connect(self.lrslchange)
self.ulab = QtGui.QLabel(self.centralwidget)
self.ulab.setText(u'위(U) 경계')
self.ulab.setGeometry(QtCore.QRect(244, 380, 100, 22))
self.usl = QtGui.QSlider(QtCore.Qt.Horizontal, self.centralwidget)
self.usl.setGeometry(QtCore.QRect(317, 380, 120, 22))
self.usl.setMinimum(100)
self.usl.setMaximum(400)
self.usl.setValue(100)
self.usl.setObjectName(_fromUtf8("usl"))
self.usl.valueChanged.connect(self.uslchange)
self.dlab = QtGui.QLabel(self.centralwidget)
self.dlab.setText(u'색상 경계값')
self.dlab.setGeometry(QtCore.QRect(441, 380, 100, 22))
self.dsl = QtGui.QSlider(QtCore.Qt.Horizontal, self.centralwidget)
self.dsl.setGeometry(QtCore.QRect(524, 380, 120, 22))
self.dsl.setMinimum(1)
self.dsl.setMaximum(255)
self.dsl.setValue(10)
self.dsl.setObjectName(_fromUtf8("dsl"))
self.dsl.valueChanged.connect(self.dslchange)
#음악 재생 부분
self.volumeSlider = Phonon.VolumeSlider(self.centralwidget)
#self.volumeSlider.setSizePolicy(QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Maximum)
self.volumeSlider.setGeometry(QtCore.QRect(460, 3, 113, 26))
self.volumeSlider.setObjectName(_fromUtf8("volumeSlider"))
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 820, 26))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menu = QtGui.QMenu(self.menubar)
self.menu.setObjectName(_fromUtf8("menu"))
self.menu_2 = QtGui.QMenu(self.menubar)
self.menu_2.setObjectName(_fromUtf8("menu_2"))
self.menu_3 = QtGui.QMenu(self.menubar)
self.menu_3.setObjectName(_fromUtf8("menu_3"))
self.menu_4 = QtGui.QMenu(self.menubar)
self.menu_4.setObjectName(_fromUtf8("menu_4"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.action = QtGui.QAction(MainWindow)
self.action.setObjectName(_fromUtf8("action"))
self.action.setShortcut("Ctrl+O")
self.action.setStatusTip(
u'음악 파일을 엽니다. 악보가 이전에 생성되지 않은 음악일 경우, 악보 생성에 시간이 소요됩니다.')
self.action.triggered.connect(lambda: self.openMusic(True))
self.action_2 = QtGui.QAction(MainWindow)
self.action_2.setObjectName(_fromUtf8("action_2"))
self.action_2.setShortcut("Ctrl+S")
self.action_2.setStatusTip(
u'악보 파일을 엽니다. 파일 확장자가 *.jhw로 끝나며 .jhw 앞에 붙은 숫자가 클 수록 난이도가 쉽습니다.')
self.action_2.triggered.connect(self.openScore)
self.action_y = QtGui.QAction(MainWindow)
self.action_y.setObjectName(_fromUtf8("action_y"))
self.action_y.setShortcut("Ctrl+Y")
self.action_y.setStatusTip(
u'YouTube 주소를 입력합니다. YouTube에서 음악을 받아 악보파일을 자동으로 생성합니다.')
self.action_y.triggered.connect(lambda: self.openMusic(False))
self.action_3 = QtGui.QAction(MainWindow, checkable=True)
self.action_3.setObjectName(_fromUtf8("action_3"))
self.action_4 = QtGui.QAction(MainWindow, checkable=True)
self.action_4.setObjectName(_fromUtf8("action_4"))
self.action_4.setChecked(True)
self.action_5 = QtGui.QAction(MainWindow)
self.action_5.setObjectName(_fromUtf8("action_5"))
self.action_6 = QtGui.QAction(MainWindow)
self.action_6.setObjectName(_fromUtf8("action_6"))
self.action_6.setShortcut("Ctrl+H")
self.action_6.setStatusTip(u'간략한 정보와 사용방법을 수록 하고 있습니다.')
self.action_6.triggered.connect(self.help)
ag = QtGui.QActionGroup(MainWindow, exclusive=True)
self.action_7 = ag.addAction(QtGui.QAction(MainWindow, checkable=True))
self.action_7.setChecked(True)
self.action_8 = ag.addAction(QtGui.QAction(MainWindow, checkable=True))
self.action_9 = ag.addAction(QtGui.QAction(MainWindow, checkable=True))
#self.action_7 = QtGui.QAction(MainWindow)
self.action_7.setObjectName(_fromUtf8("action_7"))
self.action_7.setStatusTip('Easy: *.20.jhw')
self.action_7.triggered.connect(self.easy)
#self.action_8 = QtGui.QAction(MainWindow)
self.action_8.setObjectName(_fromUtf8("action_8"))
self.action_8.setStatusTip('Medium: *.15.jhw')
self.action_8.triggered.connect(self.medi)
#self.action_9 = QtGui.QAction(MainWindow)
self.action_9.setObjectName(_fromUtf8("action_9"))
self.action_9.setStatusTip('Hard: *.10.jhw')
self.action_9.triggered.connect(self.hard)
ag2 = QtGui.QActionGroup(MainWindow, exclusive=True)
self.action_10 = ag2.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.action_10.setChecked(True)
self.action_11 = ag2.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.action_10.setObjectName(_fromUtf8("action_10"))
self.action_10.setStatusTip(u'인식 방법을 잔상 인식 모드로 설정합니다.')
self.action_10.triggered.connect(self.shadow)
self.action_11.setObjectName(_fromUtf8("action_11"))
self.action_11.setStatusTip(u'인식 방법을 배경 제거 인식 모드로 설정합니다.')
self.action_11.triggered.connect(self.bgrm)
self.menu.addAction(self.action)
self.menu.addAction(self.action_2)
self.menu.addAction(self.action_y)
self.menu.addAction(self.action_6)
self.menu_2.addAction(self.action_3)
self.menu_2.addAction(self.action_4)
self.menu_3.addAction(self.action_7)
self.menu_3.addAction(self.action_8)
self.menu_3.addAction(self.action_9)
self.menu_4.addAction(self.action_10)
self.menu_4.addAction(self.action_11)
self.menubar.addAction(self.menu.menuAction())
self.menubar.addAction(self.menu_2.menuAction())
self.menubar.addAction(self.menu_3.menuAction())
self.menubar.addAction(self.menu_4.menuAction())
self.camera = QtGui.QWidget(self.centralwidget)
self.camera.setGeometry(QtCore.QRect(0, 20, 655, 365))
self.camera.setMinimumSize(QtCore.QSize(655, 365))
self.camera.setMaximumSize(QtCore.QSize(655, 365))
self.camera.setObjectName(_fromUtf8("camera"))
self.startButton = QtGui.QPushButton(self.centralwidget)
self.startButton.setGeometry(QtCore.QRect(10, 5, 91, 23))
self.startButton.setObjectName(_fromUtf8("startButton"))
self.pauseButton = QtGui.QPushButton(self.centralwidget)
self.pauseButton.setGeometry(QtCore.QRect(101, 5, 111, 23))
self.pauseButton.setObjectName(_fromUtf8("pauseButton"))
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
#UI 부분 완성 이제 영상 부분
self.capture = None
self.fps = 29.97
self.timer = None
self.startButton.clicked.connect(self.start)
self.startButton.connect(
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_F1),
self.centralwidget), QtCore.SIGNAL('activated()'),
self.start)
self.monitor = QtGui.QVBoxLayout(self.camera)
self.startCapture()
# QProcess object for external app
self.process = QtCore.QProcess()
# QProcess emits `readyRead` when there is data to be read
self.process.readyRead.connect(self.dataReady)
# Just to prevent accidentally running multiple times
# Disable the button when process starts, and enable it when it finishes
self.process.started.connect(lambda: self.menu.setEnabled(False))
self.process.started.connect(
lambda: self.startButton.setEnabled(False))
self.process.finished.connect(lambda: self.menu.setEnabled(True))
self.process.finished.connect(
lambda: self.startButton.setEnabled(True))
self.process.finished.connect(self.scoremade)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "ARshaker", None))
self.menu.setTitle(_translate("MainWindow", "&파일", None))
self.menu_2.setTitle(_translate("MainWindow", "&화면 반전", None))
self.menu_3.setTitle(_translate("MainWindow", "&난이도", None))
self.menu_4.setTitle(_translate("MainWindow", "&인식 모드", None))
self.action.setText(_translate("MainWindow", "&음악 열기", None))
self.action_2.setText(_translate("MainWindow", "&악보 열기", None))
self.action_y.setText(_translate("MainWindow", "&Youtube에서 열기", None))
self.action_3.setText(_translate("MainWindow", "&상하 반전", None))
self.action_4.setText(_translate("MainWindow", "&좌우 반전", None))
self.action_5.setText(_translate("MainWindow", "&배경삭제", None))
self.action_6.setText(_translate("MainWindow", "&도움말", None))
self.action_7.setText(_translate("MainWindow", "&쉬움", None))
self.action_8.setText(_translate("MainWindow", "&보통", None))
self.action_9.setText(_translate("MainWindow", "&어려움", None))
self.action_10.setText(_translate("MainWindow", "&잔상 인식", None))
self.action_11.setText(_translate("MainWindow", "&배경 제거", None))
self.startButton.setText(_translate("MainWindow", "시작(F1)", None))
self.pauseButton.setText(_translate("MainWindow", "일시정지(F2)", None))
#위 경계값 가져오기
def uslchange(self):
self.ubnd = self.usl.value()
self.lenl = self.vheight * self.lrbnd
self.lenm = (self.vheight - self.ubnd) * (self.vwidth -
(2 * self.lrbnd))
self.lenr = self.vheight * self.lrbnd
self.lenu = (self.vwidth - (2 * self.lrbnd)) * self.ubnd
#좌,우 경계값 가져오기
def lrslchange(self):
self.lrbnd = self.lrsl.value()
self.lenl = self.vheight * self.lrbnd
self.lenm = (self.vheight - self.ubnd) * (self.vwidth -
(2 * self.lrbnd))
self.lenr = self.vheight * self.lrbnd
self.lenu = (self.vwidth - (2 * self.lrbnd)) * self.ubnd
#인식 크기 경계값 가져오기
def dslchange(self):
self.minsize = self.dsl.value()
# 악보생성용 서브 프로세스 호출 및 결과 기입
def dataReady(self):
cursor = self.lineEdit.textCursor()
cursor.movePosition(cursor.End)
cursor.insertText(str(self.process.readAll()))
self.lineEdit.ensureCursorVisible()
# 악보를 처음 생성했을때
def scoremade(self):
self.lineEdit.clear()
self.lineEdit.append(self.score)
if self.level is 20:
self.lineEdit.append(u'난이도: 쉬움')
elif self.level is 15:
self.lineEdit.append(u'난이도: 보통')
elif self.level is 10:
self.lineEdit.append(u'난이도: 어려움')
self.sequencer()
self.lineEdit.append(u'위의 악보가 생성되었습니다. 시작(F1)을 눌러 리듬게임을 시작하세요!')
self.stop()
#사용자 조정 인식 값 라벨 변경 및 인지
def bgrm(self):
self.dlab.setText(u'인식 최소값')
self.lineEdit.append(u'인식 방법이 배경 제거 인식 모드로 설정 되었습니다.')
self.dsl.setMinimum(1)
self.dsl.setMaximum(1000)
self.dsl.setValue(1)
self.minsize = 1
def shadow(self):
self.dlab.setText(u'색상 경계값')
self.lineEdit.append(u'인식 방법이 잔상 인식 모드로 설정 되었습니다.')
self.dsl.setMinimum(1)
self.dsl.setMaximum(255)
self.dsl.setValue(10)
self.minsize = 10
#난이도 3개
def easy(self):
self.level = 20
self.lineEdit.append(u'난이도가 쉬움으로 변경되었습니다.')
def medi(self):
self.level = 15
self.lineEdit.append(u'난이도가 보통으로 변경되었습니다.')
def hard(self):
self.level = 10
self.lineEdit.append(u'난이도가 어려움으로 변경되었습니다.')
#음악 여는 함수
def openMusic(self, type):
name = None
if type:
name = QtGui.QFileDialog.getOpenFileNames(
None, u'음악 선택 - mp3, wav, wma 확장자를 가진 파일 하나를 열어주세요',
QtGui.QDesktopServices.storageLocation(
QtGui.QDesktopServices.MusicLocation),
"Music (*.mp3 *.wav *.wma)")
else:
url, ok = QtGui.QInputDialog.getText(
None, u'음악 선택 - YouTube 주소를 입력하세요',
u'예시:https://www.youtube.com/watch?v=DVuRGCuFoa0')
if not str(url).startswith(
'https://www.youtube.com/watch?v=') or not ok:
self.lineEdit.append(u'올바르지 않은 YouTube 주소 입니다. 다시 시도하세요.')
return
else:
self.lineEdit.append(u'음원 추출 중입니다. 조금만 기다려주세요.')
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.download([str(url)])
video = pafy.new(url)
for a in reversed(video.audiostreams):
if not str(a.extension).__contains__("webm"):
songtitle = a.title + "." + a.extension
self.lineEdit.append(songtitle)
self.lineEdit.append(u'음원 추출 중입니다. 조금만 기다려주세요.')
if not os.path.isfile(songtitle):
downloader = QtCore.QThread()
#변환 subprocess 미완
#sys.stdout = open(os.devnull, "w")
#a.download(quiet=True)
#sys.stdout= saved_stdout
#name=ytfolder+a.title+ ".mp3"
if not name:
return
else:
print(name)
self.source = name[0]
self.lineEdit.clear()
self.lineEdit.append(self.source)
self.lineEdit.append(
u'음악 파일이 성공적으로 열렸습니다. 악보를 생성합니다. 완료될 때 까지 기다려 주세요.')
self.lineEdit.append(" ")
#self.player = Phonon.createPlayer(Phonon.MusicCategory,Phonon.MediaSource(self.source))
self.player = Phonon.MediaObject()
self.player.setCurrentSource(Phonon.MediaSource(self.source))
self.player.setTickInterval(100)
self.player.tick.connect(self.tick)
self.seekSlider.setMediaObject(self.player)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory)
Phonon.createPath(self.player, self.audioOutput)
self.volumeSlider.setAudioOutput(self.audioOutput)
self.title = self.source.split('\\')[self.source.count('\\')]
self.score = self.source + "." + str(self.level) + ".jhw"
cmd = 'mnb ' + str(
self.level) + ' "' + self.source + '" "' + self.score + '"'
if os.path.exists(self.score):
self.sequencer()
self.lineEdit.append(
u'이미 생성된 악보가 있습니다. 시작(F1)을 눌러 리듬게임을 시작하세요!')
self.stop()
else:
self.process.start(cmd)
#시퀀서
def sequencer(self):
self.correct = 0
f = open(self.score, 'r')
while True:
line = f.readline()
if not line: break
self.scoreLine[(int)(
line.split(" ")[0])] = line.split(" ")[1].split("\n")[0]
f.close()
self.notes = sorted(self.scoreLine.items(), key=operator.itemgetter(0))
self.lineEdit.append(u'비트 개수: ' + str(len(self.notes)) + u'개')
self.listWidget.clear()
self.listindex = 0
for note in self.notes:
bits = str(datetime.timedelta(milliseconds=note[0])).split(":")
if bits[2].endswith("000"):
bits[2] = bits[2].rstrip("000")
if len(bits[2]) < 6:
i = len(bits[2])
while i < 6:
bits[2] = bits[2] + '0'
i += 1
self.listWidget.addItem(
str(bits[1]) + ":" + str(bits[2]).replace(".", ":") + " - " +
note[1])
if self.notes.index(note) == len(self.notes) - 1:
self.totaltime = note[0]
self.lineEdit.append(u'예상 운동 시간: ' + str(bits[1]) + u'분 ' +
str(bits[2]).replace(".", u'초 '))
#악보 여는 함수
def openScore(self):
name = QtGui.QFileDialog.getOpenFileNames(
None,
u'악보 선택 - .jhw 앞에 붙은 숫자가 클 수록 난이도가 쉽습니다. (20:쉬움 15:보통 10:어려움)',
QtGui.QDesktopServices.storageLocation(
QtGui.QDesktopServices.MusicLocation), "Score (*.jhw)")
if not name:
return
else:
self.score = name[0]
if ".mp3" in self.score:
self.source = self.score.split('.mp3')[0] + '.mp3'
elif ".wma" in self.score:
self.source = self.score.split('.wma')[0] + '.wma'
elif ".wav" in self.score:
self.source = self.score.split('.wav')[0] + '.wav'
self.title = self.source.split('\\')[self.source.count('\\')]
self.lineEdit.clear()
self.lineEdit.append(self.score)
self.lineEdit.append(u'악보 파일이 성공적으로 열렸습니다. 해당 악보에 맞는 음악을 로딩합니다.')
if os.path.exists(self.source):
self.player = Phonon.MediaObject()
self.player.setCurrentSource(Phonon.MediaSource(self.source))
self.player.setTickInterval(100)
self.player.tick.connect(self.tick)
self.seekSlider.setMediaObject(self.player)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory)
Phonon.createPath(self.player, self.audioOutput)
self.volumeSlider.setAudioOutput(self.audioOutput)
self.sequencer()
self.stop()
self.lineEdit.append(
u'음악파일이 성공적으로 로드되었습니다. 시작(F1)을 눌러 리듬게임을 시작하세요!')
else:
self.lineEdit.append(u'악보 파일에 해당하는 음악파일이 없습니다. 음악파일을 먼저 열어주세요')
#도움말 함수
def help(self):
QtGui.QMessageBox.information(
None, u'팀 JHW -ARSHAKER',
u'제10회 공개 SW 개발자대회 응용SW 부문 출품작\n\n제작자: 김주현 , 황혜원\n\n원만한 사용을 위해 게임 시작 전 좌,우,위 위치 슬라이더를 조절하여 초기에 초록색┌┐이 화면에 나오도록 해주시고,\n\n가급적 카메라가 있는 방향으로 몸을 뻗으세요.\n\n초록색┌┐상태로 전환이 잘 안되는 경우 인식 모드를 번갈아 바꾸어 보세요.',
u'ARSHAKER 화이팅')
#타이머 함수
def tick(self, time):
displayTime = QtCore.QTime(0, (time / 60000) % 60, (time / 1000) % 60)
self.lcdNumber.display(displayTime.toString('mm:ss'))
timediff = self.totaltime - time
if timediff < 0:
timediff = 0
displayTime2 = QtCore.QTime(0, (timediff / 60000) % 60,
(timediff / 1000) % 60)
self.lcdr.display(displayTime2.toString('mm:ss'))
for note in self.notes:
if note[0] <= self.player.currentTime(
) and note[0] > self.listindex:
self.listindex = note[0]
self.listWidget.setCurrentRow(self.notes.index(note))
self.lcda.display(self.notes.index(note) + 1)
self.lcdl.display(len(self.notes) - self.notes.index(note) - 1)
self.lcdo.display(self.correct)
self.lcdx.display(self.notes.index(note) + 1 - self.correct)
percent = round((float(self.notes.index(note)) /
float(len(self.notes)) * 100))
perfect = round((float(self.correct) /
float(self.notes.index(note) + 1) * 100))
self.lcdg.display(int(perfect))
self.lcdpg.display(int(percent))
#self.listWidget.setCurrentIndex(self.listWidget.model().index(self.notes.index(note)))
if timediff > 0:
self.ctransition = note[1]
else:
self.ctransition = None
if self.notes.index(note) + 19 < len(self.notes):
self.listWidget.scrollTo(self.listWidget.model().index(
self.notes.index(note) + 19))
#영상 관련 함수
def diffImg(self, t0, t1, t2):
d1 = cv2.absdiff(t2, t1)
d2 = cv2.absdiff(t1, t0)
return cv2.bitwise_and(d1, d2)
def nextFrameSlot(self):
ret, frame = self.cap.read()
#상하, 좌우 반전; 기본 좌우 반전 선택
if self.action_3.isChecked():
frame = cv2.flip(frame, 0)
if self.action_4.isChecked():
frame = cv2.flip(frame, 1)
#배경 지우기 모드
if self.action_11.isChecked():
fgmask = self.fgbg.apply(frame)
#fgmask = cv2.equalizeHist(fgmask)
thrs1 = 2000
thrs2 = 4000
fgmask = cv2.Canny(fgmask, thrs1, thrs2, apertureSize=5)
left = fgmask[0:self.vheight, 0:self.lrbnd]
mid = fgmask[self.ubnd:self.vheight,
self.lrbnd:self.vwidth - self.lrbnd]
right = fgmask[0:self.vheight,
self.vwidth - self.lrbnd:self.vwidth]
up = fgmask[0:self.ubnd, self.lrbnd:self.vwidth - self.lrbnd]
#잔상 인식 모드
else:
self.t_minus = self.t
self.t = self.t_plus
self.t_plus = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
blur = self.diffImg(self.t_minus, self.t, self.t_plus)
masks = cv2.GaussianBlur(blur, (5, 5), 0)
ret, mask = cv2.threshold(masks, self.minsize, 255,
cv2.THRESH_TOZERO)
left = mask[0:self.vheight, 0:self.lrbnd]
mid = mask[self.ubnd:self.vheight,
self.lrbnd:self.vwidth - self.lrbnd]
right = mask[0:self.vheight, self.vwidth - self.lrbnd:self.vwidth]
up = mask[0:self.ubnd, self.lrbnd:self.vwidth - self.lrbnd]
leftval = cv2.countNonZero(left)
midval = cv2.countNonZero(mid)
rightval = cv2.countNonZero(right)
upval = cv2.countNonZero(up)
if (leftval is 0 and rightval is 0
and upval is 0) or (leftval < self.minsize
and rightval < self.minsize
and upval < self.minsize):
# if (leftval is 0 and rightval is 0 and upval is 0):
# if (leftval is 0 and rightval is 0 and upval is 0):
cv2.rectangle(frame, (self.lrbnd, self.ubnd),
(self.vwidth - self.lrbnd, self.vheight),
(0, 255, 0), 10)
self.transition = 'mid'
elif leftval is 0 and rightval is 0 and upval > 0 or (
leftval < upval and rightval < upval):
cv2.rectangle(frame, (self.lrbnd, 0),
(self.vwidth - self.lrbnd, self.ubnd),
(255, 255, 255), 10)
if self.transition is not 'U':
self.transition = 'U'
elif leftval > 0 and rightval is 0 and upval is 0 or (
leftval > upval and leftval > rightval):
cv2.rectangle(frame, (0, 0), (self.lrbnd, self.vheight),
(255, 0, 0), 10)
if self.transition is not 'L':
self.transition = 'L'
elif rightval > 0 and leftval is 0 and upval is 0 or (
rightval > upval and rightval > leftval):
cv2.rectangle(frame, (self.vwidth - self.lrbnd, 0),
(self.vwidth, self.vheight), (0, 0, 255), 10)
if self.transition is not 'R':
self.transition = 'R'
cv2.putText(frame,
str(leftval) + "/" + str(self.lenl), (3, 180), self.font,
0.5, (0, 255, 0), 2)
cv2.putText(frame,
str(midval) + "/" + str(self.lenm), (270, 400), self.font,
0.5, (0, 255, 0), 2)
cv2.putText(frame,
str(rightval) + "/" + str(self.lenr), (565, 180),
self.font, 0.5, (0, 255, 0), 2)
cv2.putText(frame,
str(upval) + "/" + str(self.lenu), (280, 90), self.font,
0.5, (0, 255, 0), 2)
if self.ctransition == self.transition:
self.ctransition = None
self.correct += 1
if self.ctransition is not None:
if self.ctransition == 'L':
cv2.putText(frame, self.ctransition, (250, 360), self.font, 7,
(255, 0, 0), 7)
elif self.ctransition == 'R':
cv2.putText(frame, self.ctransition, (250, 360), self.font, 7,
(0, 0, 255), 7)
elif self.ctransition == 'U':
cv2.putText(frame, self.ctransition, (250, 360), self.font, 7,
(255, 255, 255), 7)
#self.keyFix()
if ret:
# My webcam yields frames in BGR format
self.frame = cv2.cvtColor(frame, cv2.cv.CV_BGR2RGB)
else:
self.frame = np.zeros((480, 640, 3), np.uint8)
cv2.putText(self.frame,
"Please Rerun Program After Connecting Camera",
(5, 240), self.font, 0.8, (0, 255, 0), 2)
self.lineEdit.setText(
u'컴퓨터에 카메라가 설치되지 않았습니다. 카메라를 연결 후 프로그램을 재 실행 시켜주세요')
img = QtGui.QImage(self.frame, self.frame.shape[1],
self.frame.shape[0], QtGui.QImage.Format_RGB888)
pix = QtGui.QPixmap.fromImage(img)
self.video_frame.setPixmap(pix)
def startCapture(self):
if not self.capture:
self.cap = cv2.VideoCapture(0)
self.cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.vwidth)
self.cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.vheight)
self.video_frame = QtGui.QLabel()
self.pauseButton.clicked.connect(self.stop)
self.pauseButton.connect(
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_F2),
self.centralwidget),
QtCore.SIGNAL('activated()'), self.stop)
# self.capture.setFPS(1)
# self.setParent(self)
# self.setWindowFlags(QtCore.Qt.Tool)
self.monitor.addWidget(self.video_frame)
self.start()
'''def endCapture(self):
self.capture.deleteLater()
self.capture = None'''
def setFPS(self, fps):
self.fps = fps
def start(self):
if self.timer is None:
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.nextFrameSlot)
self.timer.start(1000. / self.fps)
if self.player is not None and self.player.state(
) != Phonon.PlayingState:
self.player.play()
def stop(self):
if self.timer is not None:
self.timer.stop()
self.timer = None
if self.player is not None and self.player.state(
) == Phonon.PlayingState:
self.player.pause()
def deleteLater(self):
self.cap.release()
super(QtGui.QWidget, self).deleteLater()
import numpy as np
import cv2
cap = cv2.VideoCapture(0)
#cap = cv2.VideoCapture('video/people-walking.mp4')
fgmogbg = cv2.BackgroundSubtractorMOG() # Creates a background object.
fgmog2bg = cv2.BackgroundSubtractorMOG2(
) # It detects and marks shadows as well.
while True:
ret, frame = cap.read()
# To get the foreground mask.
fgmogmask = fgmogbg.apply(frame)
fgmog2mask = fgmog2bg.apply(frame)
cv2.imshow('original', frame)
cv2.imshow('fgmogmask', fgmogmask)
cv2.imshow('fgmog2mask', fgmog2mask)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
# Note: For OpenCV version-3:
# use cv2.createBackgroundSubtractorMOG() in line 5 and cv2.createBackgroundSubtractorMOG2() in line 6.
RESALTAR_BORDES = 4
RESALTAR_LINEAS_RECTAS = 5
RESALTAR_AZUL = 6
RESALTAR_ROJO = 7
RESALTAR_VERDE = 8
RESALTAR_BLANCO = 9
DETECTAR_MOVIMIENTO = 10
RESALTAR_COLORES_FUEGO = 11
PARAMETRO_ROJO = 0
PARAMETRO_AZUL = 1
PARAMETRO_VERDE = 3
PARAMETRO_BLANCO = 4
mog = cv2.BackgroundSubtractorMOG(history=10,
nmixtures=6,
backgroundRatio=0.9,
noiseSigma=0.1)
#funcion que intensifica los colores en un rango(min y max)
#rango minino de los tres canales HSV: hMin,sMin,vMin
#rango maximo de los tres canales HSV: hMax,sMax,vMax
def aumentarIntensidadPorRangoDeColor(frame, hMin, hMax, sMin, sMax, vMin,
vMax):
#convierte el frame al espacio de color hsv
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#Se crea un array con las posiciones minimas y maximas
lower = np.array([hMin, sMin, vMin])
upper = np.array([hMax, sMax, vMax])
def inicializarMOG():
global mog
mog = cv2.BackgroundSubtractorMOG(history=500,
nmixtures=6,
backgroundRatio=0.9,
noiseSigma=0.1)
import cv2
import numpy as np
def get_frame(cap, scaling_factor):
ret, frame = cap.read()
frame = cv2.resize(frame, None, fx=scaling_factor,
fy=scaling_factor, interpolation=cv2.INTER_AREA)
return frame
if __name__=='__main__':
cap = cv2.VideoCapture(0)
bgSubtractor = cv2.BackgroundSubtractorMOG()
history = 100
while True:
frame = get_frame(cap, 0.5)
mask = bgSubtractor.apply(frame, learningRate=1.0/history)
mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
cv2.imshow('Input frame', frame)
cv2.imshow('Moving Objects', mask & frame)
c = cv2.waitKey(10)
if c == 27:
break
cap.release()
cv2.destroyAllWindows()
def startCamera(self):
'''start Camera
'''
cap = cv2.VideoCapture(0)
dialogbox = Form()
dialogbox.show()
dialogbox.liveCameraFlag = True
while (cap.isOpened()):
# Capture frame-by-frame
ret, frame = cap.read()
# Our operations on the frame come here
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if dialogbox.filterFlag == "2D Convolution - Average":
kernel = np.ones((5, 5), np.float32) / 25
gray = cv2.filter2D(gray, -1, kernel)
if dialogbox.filterFlag == "2D Convolution - Smooth":
gray = cv2.blur(gray, (5, 5))
if dialogbox.filterFlag == "2D Convolution - Gaussian":
gray = cv2.GaussianBlur(gray, (5, 5), 0)
if dialogbox.filterFlag == "2D Convolution - Median":
gray = cv2.medianBlur(gray, 5)
if dialogbox.filterFlag == "2D Convolution - Bilateral":
gray = cv2.bilateralFilter(gray, 9, 75, 75)
if dialogbox.filterFlag == "Canny Filter":
gray = cv2.Canny(gray, 100, 20)
if dialogbox.filterFlag == "Invert":
gray = (255 - gray)
if dialogbox.filterFlag == "Adaptive Threshold":
gray_blur = cv2.GaussianBlur(gray, (15, 15), 0)
gray = cv2.adaptiveThreshold(gray_blur, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY_INV, 11, 1)
if dialogbox.filterFlag == "Laplacian Edge":
# remove noise
img = cv2.GaussianBlur(gray, (3, 3), 0)
# convolute with proper kernels
gray = cv2.Laplacian(img, cv2.CV_64F)
if dialogbox.filterFlag == "Background Subtract":
fgbg = cv2.BackgroundSubtractorMOG()
history = 10
while dialogbox.filterFlag == "Background Subtract":
retVal, frame = cap.read()
fgmask = fgbg.apply(frame, learningRate=1.0 / history)
cv2.imshow('Live Camera', fgmask)
globimg = gray
if cv2.waitKey(1) & 0xFF == ord('q'):
cap.release()
cv2.destroyAllWindows()
globimg = 'OFF'
dialogbox.close()
break
if dialogbox.getImageFlag == True:
if dialogbox.blackandwhiteFlag == True:
self.capturedImage = (self.convertImage(gray))
else:
self.capturedImage = (self.convertImage(frame))
if dialogbox.recordingFlag == True:
if dialogbox.blackandwhiteFlag == True:
self.recordingList.append(self.convertImage(gray))
else:
self.recordingList.append(self.convertImage(frame))
if dialogbox.blackandwhiteFlag == True:
# Display the resulting frame in grey
cv2.imshow('Live Camera', gray)
globimg = gray
else:
# Display the resulting frame in colour
cv2.imshow('Live Camera', frame)
globimg = frame
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if dialogbox.liveCameraFlag == False:
break
# When everything is done, release the capture
cap.release()
cv2.destroyAllWindows()
globimg = 'OFF'
def mainfun(self):
simgnum = 1
imgNum = 1
template = cv2.imread('outkicktemp71.png',0)
tempsiz = cv2.imread('tempsize3.png',0)
wrframe = False
size = np.size(template)
skelt = np.zeros(template.shape,np.uint8)
ret,img = cv2.threshold(template,127,255,0)
element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
done = False
while( not done):
eroded = cv2.erode(template,element)
temp = cv2.dilate(eroded,element)
temp = cv2.subtract(template,temp)
skelt = cv2.bitwise_or(skelt,temp)
template = eroded.copy()
zeros = size - cv2.countNonZero(template)
if zeros==size:
done = True
#cv2.imshow('Backgr',skelt)
#cv2.waitKey(0)
w, h = skelt.shape[::-1]
print w
print h
threshold = 0.08
fgbg = cv2.BackgroundSubtractorMOG()
cap = cv2.VideoCapture("outkick73.mp4")
while(1):
ret, img_rgb = cap.read()
fgmask = fgbg.apply(img_rgb)
#cv2.imshow('FGmsk',fgmask)
size = np.size(fgmask)
skel = np.zeros(fgmask.shape,np.uint8)
ret,fgmask = cv2.threshold(fgmask,127,255,0)
element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
done = False
while( not done):
eroded = cv2.erode(fgmask,element)
temp = cv2.dilate(eroded,element)
temp = cv2.subtract(fgmask,temp)
skel = cv2.bitwise_or(skel,temp)
fgmask = eroded.copy()
zeros = size - cv2.countNonZero(fgmask)
if zeros==size:
done = True
#cv2.imshow('Backgr',skel)
imgNum+= 1
if(self.status == False):
res = cv2.matchTemplate(skel,skelt,cv2.TM_CCOEFF_NORMED)
loc = np.where( res >= threshold)
for pt in zip(*loc[::-1]):
cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,0,255), 1)
#winsound.Beep(2500, 40)
#os.system("sound.wav")
wrframe = True
self.trackwin = self.objtr.run_main(pt[0], pt[1], w, h, img_rgb)
self.status = True
elif(self.status == True):
self.trackwin = self.objtr.run_main2(self.trackwin, img_rgb)
winsound.Beep(2500, 10)
if cv2.waitKey(1) & 0xFF == ord('q'):
self.status = False
# cv2.circle(img_rgb,(pt[0], pt[1]),3,100+(255),-1)
if(wrframe == True):
cv2.imwrite('savepic//('+str(simgnum)+').jpg',img_rgb)
simgnum=simgnum+1
wrframe = False
# cv2.imwrite('res.png',img_rgb)
# cv2.imshow('Detected Val',img_rgb)
k = cv2.waitKey(True)
if k == 27:
break
elif k == 48:
time.sleep(10.0)
cv2.imshow('Detected Val',img_rgb)
cv2.destroyAllWindows()
def __init__(self):
self.motionDetected = False
self.motionDetectedHold = False
self.robot_view_motion = rospy.get_param('~robot_view_motion', False)
self.Vp_MD_Subtr_UseFrmDiff = rospy.get_param(
'~Vp_MD_Subtr_UseFrmDiff', False)
self.Vp_MD_Subtr_UseMog = rospy.get_param('~Vp_MD_UseSubtractorMog',
True)
self.Vp_ME_UseLkTractor = rospy.get_param('~Vp_ME_UseLkTractor', False)
self.md_visualMsg = visualMsg()
self.md_pub = rospy.Publisher(
"tpc_visual", visualMsg, queue_size=5
) #name.data_class,subscriber_listener=None, tcp_nodelay=False, latch=False, headers=None, queue_size=None
self.pub_count = 0
self.lk_tracker = LKTracker()
self.cam = PiCamera()
self.cam.resolution = (640, 480)
self.cam.framerate = 24
self.rawCapture = PiRGBArray(self.cam)
time.sleep(0.1)
#self.cap = cv2.VideoCapture(0)
#self.r = rospy.Rate(24)
self.detect_box = (10, 10, 620, 460) #None (x,y,w,h)
self.track_box = None #rotated Rect (center, size, angle) | regular cvRect (x,y,w,h)
self.keypoints = []
self.frame_idx = 0
self.detect_interval = 8
self.mask = None
self.feature_size = rospy.get_param("~feature_size", 2)
self.prev_grey = None
self.grey = None
self.avg = None
self.bgsMOG = cv2.BackgroundSubtractorMOG(
1, 6, 0.9,
.3) #([history, nmixtures, backgroundRatio[, moiseSigma]])
"""
history - length of the history
nmixtures - number of Gaussian mixtures
"""
# Subtractor parameters
self.delta_thresh = rospy.get_param('~subtr_delta_thresh', 20)
self.min_area = rospy.get_param('~subtr_min_area',
3000) # ignore too small contour
#good feature params
self.gf_maxCorners = rospy.get_param('~gf_maxCorners',
200) # 500 | 200
self.gf_qualityLevel = rospy.get_param("~gf_qualityLevel",
0.02) # 0.3 | 0.02
self.gf_minDistance = rospy.get_param("~gf_minDistance", 7) # 10 | 7
self.gf_blockSize = rospy.get_param("~gf_blockSize", 10) # 7 | 10
self.gf_useHarrisDetector = rospy.get_param("~gf_useHarrisDetector",
True)
self.gf_k = rospy.get_param("~gf_k", 0.04)
self.gf_params = dict(maxCorners=self.gf_maxCorners,
qualityLevel=self.gf_qualityLevel,
minDistance=self.gf_minDistance,
blockSize=self.gf_blockSize,
useHarrisDetector=self.gf_useHarrisDetector,
k=self.gf_k)
if DEBUG_L1: print('Info:motionDetect intialized.')
import numpy as np
import imutils
import cv2
cap = cv2.VideoCapture('Q1.avi')
fgbg = cv2.BackgroundSubtractorMOG(history=1,
nmixtures=1,
backgroundRatio=0.7,
noiseSigma=0)
numframes = cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)
count = 1
while count <= 100:
name = 'Frame%s.jpg' % count
ret, frame = cap.read()
fgmask = fgbg.apply(frame)
# print numframes
# cv2.imwrite(name,fgmask)
cv2.imshow('frame', fgmask)
cv2.waitKey(100)
count += 1
cap.release()
import cv2
import numpy as np
backsub = cv2.BackgroundSubtractorMOG()
cap = cv2.VideoCapture(0)
while True:
_, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# hranice filtra
lower_red = np.array([10, 90, 10])
upper_red = np.array([254, 200, 100])
# maskovanie obrazu
mask = cv2.inRange(hsv, lower_red, upper_red)
res = cv2.bitwise_and(frame, frame, mask=mask)
# detekcia zmeny
fgmask = backsub.apply(mask, None, 0.001)
contours, hierarchy = cv2.findContours(fgmask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
# velkost videa spravi5 automatiku
Y = 480
X = 640
# rozdelenie obrazu
cv2.line(frame, (0, Y / 2), (X, Y / 2), (255, 0, 255), 1)
cv2.line(frame, (X / 2, 0), (X / 2, Y), (255, 0, 255), 1)
try:
hierarchy = hierarchy[0]
except:
hierarchy = []
for contour, hier in zip(contours, hierarchy):
(x, y, w, h) = cv2.boundingRect(contour)
if w > 20 and h > 20:
def __init__(self):
self._windowManager = WindowManager('Track', self.onKeypress)
self._captureManager = CaptureManager(cv2.VideoCapture(0),
self._windowManager, True)
self._fgbg = cv2.BackgroundSubtractorMOG()
def srs():
ip = cv2.VideoCapture(IPVIDEONAME)
bgsubtractor = cv2.BackgroundSubtractorMOG()
count = 'N/A'
heavyweigthcount = 0
mediumweigthcount = 0
kernel = np.ones((5, 5), np.uint8)
PAUSE = False
Framecount = 0
fc1 = 0
fc2 = 0
y, e = 0, 0 #Setting Defaults to avoid Errors
speed = "N/A"
flagtostartlogic = False
detectedVehicle = "N/A"
if IPVIDEONAME == 0:
num_frames = 120
# print "Capturing {0} frames".format(num_frames)
# Start time
start = time.time()
# Grab a few frames
for i in xrange(0, num_frames):
ret, frame = ip.read()
# End time
end = time.time()
# Time elapsed
seconds = end - start
# print "Time taken : {0} seconds".format(seconds)
# Calculate frames per second
fps = num_frames / seconds
print("fps", fps)
else:
fps = ip.get(cv2.cv.CV_CAP_PROP_FPS)
print "Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}".format(
fps)
while ip.isOpened():
ret, img = ip.read()
if ret:
copy = img.copy()
# copy=cv2.resize(copy,(400,400))
# img = cv2.resize(img, (400, 400))
Framecount = Framecount + 1
timestamp = datetime.datetime.now()
ts = timestamp.strftime("%A %d %B %Y %I:%M:%S%p")
cv2.putText(copy, ts, (10, copy.shape[0] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 0, 255), 1)
# cv2.imshow("CCTV",copy)
# Setting Imaginary Lines and points to check
############################################################################################################
if LINE_ORIENTATION == "Vertical Reference Line":
#HardCoded Points
##################################################################################################################################
# pt1 = img.shape[1] / 2
# pt2 = img.shape[1] / 2 + 100
# cv2.line(copy, (pt1, 0), (img.shape[1] / 2, img.shape[0]), (255, 127, 0), 2)
# cv2.line(copy, (pt2, 0), (img.shape[1] / 2+100, img.shape[0]), (255, 127, 0), 2)
################################################################################################################################
#Using DISTBETWEENPOINTS variable
########################################################################################################################################
pt1 = img.shape[1] / 2
pt2 = img.shape[1] / 2 + DISTBETWEENPOINTS
cv2.line(copy, (pt1, 0), (pt1, img.shape[0]), (255, 127, 0), 2)
cv2.line(copy, (pt2, 0), (pt2, img.shape[0]), (255, 127, 0), 2)
######################################################################################################################################
else:
# HardCoded Points
##################################################################################################################################
# pt2 = img.shape[0] / 2 - 50 # Swapped pt1 and pt2 positons not tested
# pt1 = img.shape[0] / 2
# cv2.line(copy, (0, pt1), (img.shape[1], pt1), (255, 127, 0), 2)
# cv2.line(copy, (0,pt2), (img.shape[1], pt2), (255, 127, 0), 2)
##################################################################################################################################
# Using DISTBETWEENPOINTS variable
########################################################################################################################################
pt2 = img.shape[
0] / 2 - DISTBETWEENPOINTS # Swapped pt1 and pt2 positons not tested
pt1 = img.shape[0] / 2
cv2.line(copy, (0, pt1), (img.shape[1], pt1), (255, 127, 0), 2)
cv2.line(copy, (0, pt2), (img.shape[1], pt2), (255, 127, 0), 2)
######################################################################################################################################
# Preprocessing the Video
############################################################################################################
imggray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
imggray = cv2.GaussianBlur(imggray, (5, 5), 0)
backsubimg = bgsubtractor.apply(imggray, None, 0.01)
# cv2.imshow("BGSubImg",backsubimg)
dilate = backsubimg
for i in range(9):
dilate = cv2.erode(dilate, None, iterations=1)
dilate = cv2.dilate(dilate, None, iterations=2)
dilate = cv2.dilate(dilate, None, iterations=1)
# cv2.imshow("Erode",dilate)
############################################################################################################
# Finding Countours and Drawing them
############################################################################################################
contours, hierarchy = cv2.findContours(dilate, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# cv2.imshow('After Contouring', dilate)
# cv2.drawContours(img, contours, -1, (0, 255, 0), 3)
for c in contours:
(x, y, w, h) = cv2.boundingRect(c)
# cv2.line(test, (img.shape[0]/2,0), (img.shape[0]/2,img.shape[1]), (255, 127, 0), 2)
cv2.rectangle(copy, (x, y), (x + w, y + h), (255, 0, 0), 2)
M = cv2.moments(c)
if M["m00"] != 0: #Fixed Divide By Zero Error
cx = int(M["m10"] / M["m00"])
cy = int(M["m01"] / M["m00"])
else:
cx, cy = 0, 0
#print(cx,xofline)
if flagtostartlogic:
if LINE_ORIENTATION == "Vertical Reference Line":
if cx >= pt1 and cx <= pt1 + 10:
fc1 = Framecount
# e=time.time()
# print("E",e)
count = count + 1
print "Total Count", count
totalcounter.setText(str(count))
print "Countour Area", cv2.contourArea(c)
if cv2.contourArea(c) >= MWR1 and cv2.contourArea(
c) <= MWR2:
mediumweigthcount = mediumweigthcount + 1
print "Medium Weighted Vehicle ", mediumweigthcount
mediumcounter.setText(str(mediumweigthcount))
detectedVehicle = "Medium Weighted Vehicle"
else:
heavyweigthcount = heavyweigthcount + 1
print "Heavy Weighted Vehicle ", heavyweigthcount
heavycounter.setText(str(heavyweigthcount))
detectedVehicle = "Heavy Weighted Vehicle"
if (RRM == detectedVehicle):
text = alertholder.text()
alertholder.setText(
text +
"\n Restricted Vehicle type found on Road")
detectedVehicle = "N/A"
else:
detectedVehicle = "N/A"
if cx >= pt2 and cx < pt2 + 10:
fc2 = Framecount
numframe = fc2 - fc1
# print("NumberofFrames",numframe)
try:
t = numframe / fps
except ZeroDivisionError:
continue
# print("t",t)
# print("coincide")
# s=time.time()
# print("S", s)
# y=s-e
# print("Y",y)
try:
speed = round((0.02 * 3600 / t) % 100, 2)
# speed = 2*1000/(numframe*fps)
# speed = abs(speed)
# # speed = '{:.2f}'.format(speed).replace('.', '')
except:
continue
print speed, "km/h"
if (speed > SPEED_LIMIT):
name = "Snaps\\" + "ID" + str(
count) + " " + str(
speed) + " " + "kmph" + ".jpg"
# crop_img = img[int(y):int(y+w+100),int(x):int(x+h+100)]
crop_img = img[int(y):int(y + w),
int(x):int(x + h)]
cv2.imwrite(name, crop_img)
text = alertholder.text()
alertholder.setText(text +
"\n Speed limit crossed")
# # imagefornumberplate
# if cx==img.shape[1]/2:
# snap = "NumberPlate\\"+"xyz"+".png"
# crop_img = copy[int(y):int(y + w ), int(x):int(x + h)]
# cv2.imwrite(name, crop_img)
fc2 = 0
fc1 = 0
numframe = 0
else:
if cy >= pt1 and cy <= pt1 + 19:
fc1 = Framecount
# e = time.time()
count = count + 1
print "Total Count", count
totalcounter.setText(str(count))
print "Countour Area", cv2.contourArea(c)
if cv2.contourArea(c) >= MWR1 and cv2.contourArea(
c) <= MWR2:
mediumweigthcount = mediumweigthcount + 1
print "Medium Weighted Vehicle ", mediumweigthcount
mediumcounter.setText(str(mediumweigthcount))
detectedVehicle = "Medium Weighted Vehicle"
else:
heavyweigthcount = heavyweigthcount + 1
print "Heavy Weighted Vehicle ", heavyweigthcount
heavycounter.setText(str(heavyweigthcount))
detectedVehicle = "Heavy Weighted Vehicle"
if (RRM == detectedVehicle):
text = alertholder.text()
alertholder.setText(
text +
"\n Restricted Vehicle type found on Road")
detectedVehicle = "N/A"
else:
detectedVehicle = "N/A"
if cx >= pt2 and cx < pt2 + 20:
# print
fc2 = Framecount
numframe = fc2 - fc1
# print("NumberofFrames", numframe)
t = numframe / fps
# s=time.time()
# y=s-e
try:
speed = round((0.05 * 3600 / t) % 100, 2)
# speed = 0.05/ (numframe * fps)
except ZeroDivisionError:
continue
print speed, "km/h"
if (speed > SPEED_LIMIT):
name = "Snaps\\" + "ID" + str(
count) + " " + str(
speed) + " " + "kmph" + ".jpg"
# crop_img = img[int(y):int(y+w+100),int(x):int(x+h+100)]
crop_img = img[int(y):int(y + w),
int(x):int(x + h)]
cv2.imwrite(name, crop_img)
text = alertholder.text()
alertholder.setText(text +
"\n Speed limit crossed")
fc2 = 0
fc1 = 0
############################################################################################################
# Drawing Centroids
###########################################################################################################
cv2.circle(copy, (cx, cy), 3, (255, 0, 255), -1)
cv2.putText(
copy, "Count: " + str(count) + " Speed: " + str(speed) +
" kmph", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
(0, 255, 0), 2)
# copy=cv2.resize(copy,(420,276))
# cv2.namedWindow("Detected Vehicles", cv2.cv.CV_WINDOW_AUTOSIZE)
cv2.imshow("Detected Vehicles", copy)
############################################################################################################
# Mechanism for sustaining pause,play,nextFrame which is set in the outer while loop
############################################################################################################
while (PAUSE):
k = cv2.waitKey()
# print(k)
if k == 32: # PAUSE Video Using Spacebar
PAUSE = False
if k == 13: # Next Frame Using Enter
break
if k == 27: # Exit When in Paused State using ESC
PAUSE = False
break
############################################################################################################
# Setting FPS and pause state
############################################################################################################
k = cv2.waitKey(30)
if k == 27:
break
if k == 32:
PAUSE = True
if k == ord('s'):
flagtostartlogic = True
count = 0
speed = 0
############################################################################################################
# If no next frame is available i.e ret is false
################################################################################################################
else:
print("Video Ended")
email()
break
###############################################################################################################
ip.release()
cv2.destroyAllWindows()
else:
camera = cv2.VideoCapture(args["video"])
fourcc = cv2.cv.CV_FOURCC('m', 'p', '4', 'v')
video = cv2.VideoWriter('MOG_scaling_nov.avi', fourcc, 10, (640, 480), True)
_object_type = "Car"
_temp_path = args["tempfolder"]
_model_path = args["modelpath"]
# Load the classifier
clf = joblib.load(_model_path)
firstFrame = None
fgbg = cv2.BackgroundSubtractorMOG(history=2,
nmixtures=5,
backgroundRatio=0.6,
noiseSigma=0.7)
count = 0
car_count = 0
frame_count = 0
# loop over the frames of the video
while True:
# grab the current frame and initialize the occupied/unoccupied text
(grabbed, frame) = camera.read()
text = "Unoccupied"
# if the frame could not be grabbed, then we have reached the end of the video
if not grabbed:
break
def get_center_pixel(trial_folder, num_images):
left_image_folder = os.path.join(trial_folder, 'left')
right_image_folder = os.path.join(trial_folder, 'right')
xyz_folder = os.path.join(trial_folder, 'xyz')
center_pixels = []
xyzs = []
left_fgbg = cv2.BackgroundSubtractorMOG()
right_fgbg = cv2.BackgroundSubtractorMOG()
left_images_list = os.listdir(left_image_folder)
left_images_list = [
image for image in left_images_list if image.endswith('.jpg')
]
assert len(
left_images_list) > num_images, 'Cannot fetch %d images in %s' % (
num_images, left_images_list)
idx = 0
left_bkg_image = '%s-%d.jpg' % ('left', len(left_images_list) - 1)
right_bkg_image = '%s-%d.jpg' % ('right', len(left_images_list) - 1)
left_image = cv2.imread(os.path.join(left_image_folder, left_bkg_image))
right_image = cv2.imread(os.path.join(right_image_folder, right_bkg_image))
left_fgmask = left_fgbg.apply(left_image)
right_fgmask = right_fgbg.apply(right_image)
while True:
left_image_name = '%s-%d.jpg' % ('left', idx)
right_image_name = '%s-%d.jpg' % ('right', idx)
xyz_filename = '%s-%d.json' % ('xyz', idx)
left_image = cv2.imread(
os.path.join(left_image_folder, left_image_name))
right_image = cv2.imread(
os.path.join(right_image_folder, right_image_name))
xyz_file = os.path.join(xyz_folder, xyz_filename)
left_fgmask = left_fgbg.apply(left_image)
right_fgmask = right_fgbg.apply(right_image)
left_contours, left_hierarchy = cv2.findContours(
left_fgmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
right_contours, right_hierarchy = cv2.findContours(
right_fgmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# find the largest contour in the mask, then use
# it to compute the minimum enclosing circle and
# centroid
left_xy_radius = []
right_xy_radius = []
for contour in left_contours:
if contour.shape[0] < 3:
continue
(x, y), radius = cv2.minEnclosingCircle(contour)
left_xy_radius.append((int(x), int(y), radius))
for contour in right_contours:
if contour.shape[0] < 3:
continue
(x, y), radius = cv2.minEnclosingCircle(contour)
right_xy_radius.append((int(x), int(y), radius))
if not left_xy_radius:
left_x = 0
left_y = 0
left_radius = 0
else:
left_xy_radius = sorted(left_xy_radius, key=lambda tup: tup[0])
left_x, left_y, left_radius = left_xy_radius[-1]
if not right_xy_radius:
right_x = 0
right_y = 0
right_radius = 0
else:
right_xy_radius = sorted(right_xy_radius, key=lambda tup: tup[0])
right_x, right_y, right_radius = right_xy_radius[-1]
center_pixels.append([left_x, left_y, right_x, right_y])
tmp_xyz = []
with open(xyz_file, 'r') as f:
data = json.load(f)
tmp_xyz.append(data['xyz'][0]['x'])
tmp_xyz.append(data['xyz'][0]['y'])
tmp_xyz.append(data['xyz'][0]['z'])
xyzs.append(tmp_xyz)
idx += 1
if idx == num_images:
break
assert len(left_images_list) > idx, 'Cannot fetch %d images in %s' % (
num_images, left_image_folder)
return center_pixels, xyzs
width, height = im.size
im = im.convert("L")
data = im.getdata()
data = np.matrix(data, dtype='float') / 255.0
new_data = np.reshape(data, (width, height))
return new_data
def ImageToMatrix2(im):
mx = scipy.misc.fromimage(im)
return mx
root_path = "./"
cap = cv2.VideoCapture("data/test.mp4")
fgbg = cv2.BackgroundSubtractorMOG(500, 10, 0.2)
#fgbg = cv2.createBackgroundSubtractorMOG2()
#fgbg = cv2.createBackgroundSubtractorMOG2()
#fgbg.setHistory(500)
#fgbg.setNMixtures(10)
#fgbg.setBackgroundRatio(0.2)
fnprex = "getting_mp4_"
predict_filelist = root_path + "predict_filelist.txt"
pfl = open(predict_filelist,'w')
j = 1
while (1):
def __init__(self):
self.PI = 3.14159
self.bg_subtractor = cv2.BackgroundSubtractorMOG(history=200,
nmixtures=5,
backgroundRatio=0.7,
noiseSigma=0)
# coding: utf-8
# ## Background Subtraction
# ### 1. Gaussian Mixture-based Background/Foreground Segmentation Algorithm
# In[ ]:
# OpenCV 2.4.13 only
import numpy as np
import cv2
cap = cv2.VideoCapture('walking.avi')
# Initlaize background subtractor
foreground_background = cv2.BackgroundSubtractorMOG()
while True:
ret, frame = cap.read()
# Apply background subtractor to get our foreground mask
foreground_mask = foreground_background.apply(frame)
cv2.imshow('Output', foreground_mask)
if cv2.waitKey(1) == 13:
break
cap.release()
cv2.destroyAllWindows()
def runCamera(cameraName):
try:
motionDetectedTimestamp = ""
# Connect to database
conn = sqlite3.connect('/home/pc/opencv_database.db')
c = conn.cursor()
# Get camera values from database
ip = retrieveFromDatabase("ip", cameraName)
port = retrieveFromDatabase("port", cameraName)
password = retrieveFromDatabase("password", cameraName)
# Create camera url
mpegURL = "http://" + ip + ":" + port + "/videostream.asf?user=admin&pwd=" + password + "&resolution=32&rate=0&.mpg"
# Specify the video to be captured
cap = cv2.VideoCapture(mpegURL)
# Get the starting time and starting video number
startTime = time.time()
videoNumber = 1
# Codec and VideoWriter object for saving the video
fileSaveDirectory = retrieveDirectoryFromDB()
fourcc = cv2.cv.CV_FOURCC(*'XVID')
out = getOutputFile(fileSaveDirectory, videoNumber, fourcc)
fgbg = cv2.BackgroundSubtractorMOG()
motionDetectedFrameCount = 0
motionDetected = False
mute = True
# While the camera is recording
while (True):
# Check for any keys that were pressed
k = cv2.waitKey(30) & 0xff
if k == ord('q') or k == 27:
break
elif k == ord('k'):
# Generate a new background
fgbg = cv2.BackgroundSubtractorMOG()
elif k == ord('m'):
mute = not mute
elif k == ord('w'):
# Move camera up
moveCamera(password, ip, port, 0)
elif k == ord('a'):
# Move camera left
moveCamera(password, ip, port, 4)
elif k == ord('s'):
# Move camera down
moveCamera(password, ip, port, 2)
elif k == ord('d'):
# Move camera right
moveCamera(password, ip, port, 6)
# Stop any camera movement
moveCamera(password, ip, port, 1)
# Read the current frame from the camera
ret, frame = cap.read()
# If there has been motion detected for more than a specified number of frames, generate a new mask
if motionDetectedFrameCount > 1:
fgbg = cv2.BackgroundSubtractorMOG()
motionDetectedFrameCount = 0
# Apply the mask to the frame
fgmask = fgbg.apply(frame)
kernel = np.ones((5, 5), np.uint8)
fgmask = cv2.erode(fgmask, kernel, iterations=1)
fgmask = cv2.dilate(fgmask, kernel, iterations=4)
# Find differences between the mask and frame, if any. These are called contours
contours, hierarchy = cv2.findContours(fgmask, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)
# If there are no contours an error will be thrown. If there are contours:
if len(contours) != 0:
motionDetectedFrameCount += 1
motionDetected = True
cnt = contours[0]
x, y, w, h = cv2.boundingRect(cnt)
minX = x
minY = y
maxX = x + w
maxY = y + h
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
if x < minX:
minX = x
elif y < minY:
minY = y
elif (x + w) > maxX:
maxX = (x + w)
elif (y + h) > maxY:
maxY = (y + h)
# Draw a target around the motion detected
centerX = (minX + maxX) / 2
centerY = (minY + maxY) / 2
cv2.rectangle(frame, (centerX, centerY), (centerX, centerY),
(255, 000, 255), 2)
cv2.rectangle(frame, (minX, minY), (maxX, maxY),
(255, 000, 255), 2)
# Play a sound to alert the user of motion detected
if not mute:
os.system("aplay beep.wav")
# Record movement time of occurrence in log
#if (motionDetectedTimestamp != time.asctime(time.localtime())):
# motionDetectedTimestamp = time.asctime(time.localtime())
# logTimestamp()
# Put text over video frame
# Put a timestamp on the video frame
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(frame, str(time.asctime(time.localtime())), (0, 25),
font, 1, (0, 0, 0), 7)
cv2.putText(frame, str(time.asctime(time.localtime())), (0, 25),
font, 1, (255, 255, 255), 2)
# Add MUTE text if the program is muted
if mute:
cv2.putText(frame, "MUTE", (555, 475), font, 1, (0, 0, 255), 4)
# Show the frame, and write it to the .avi file
cv2.imshow('Video', frame)
out.write(frame)
# Find how long the routine has been running for
endTime = time.time()
elapsedTime = endTime - startTime
# Save the video after a specified number of seconds
if elapsedTime >= 4:
out.release()
# If there was motion detected during the recording, move on to the next video number. Otherwise write over this video
# If there are more than a specified number of videos, the count is set back to 1 so they can all be written over
if (videoNumber == 2000) and (motionDetected == True):
motionDetected = False
videoNumber = 1
elif motionDetected == True:
motionDetected = False
videoNumber += 1
out = getOutputFile(fileSaveDirectory, videoNumber, fourcc)
startTime = time.time()
cap.release()
out.release()
cv2.destroyWindow('Video')
except:
pass
class datasheet: date_time = time.ctime() Bus_route = "XYZ" Location = "XYZ" no_of_person_going_in = 0 no_of_person_coming_out = 0 no_of_person_in = 0 def Distance(a,b): c = (a[0]-b[0])**2 + (a[1]-b[1])**2 return c**0.5 frame_count=0 if(len(sys.argv)>1): cap = cv2.VideoCapture(sys.argv[1]) else: cap = cv2.VideoCapture(0) fgbg = cv2.BackgroundSubtractorMOG(200,5,0.6,0) distance =0 #prev_distance=0 # pts = [] incount=0 outcount=0 #prev_center = None circles=[] data = datasheet() #data = [] #perv_location = '' ret, firstFrame = cap.read() grayFirst = cv2.cvtColor(firstFrame, cv2.COLOR_BGR2GRAY) while(1): # if(frame_count==302):continue ret, frame = cap.read()
def conquer(self, cap, start, end):
# Background Subtraction parameters
i = 0
fgbg = cv2.BackgroundSubtractorMOG()
# Resutls
scenes = []
# Scene feature initialization
exp_avrg = 0
max_bspeed = 0
max_brightness = 0
avrg_brightness = 0
# Iterating over the frames
last_frame = []
first_frame = []
current_frame_start = start
currentframe = start
while currentframe < end:
# Locking the capture to get the frame
self.lock.acquire()
cap.set(cv2.cv.CV_CAP_PROP_POS_FRAMES, currentframe - 1)
ret, frame = cap.read()
self.lock.release()
if ret:
# Save the first frame
if len(first_frame) == 0:
first_frame = frame
# Apply the background subtraction
if i == 2:
fgbg = cv2.BackgroundSubtractorMOG()
i = 0
fgmask = fgbg.apply(frame)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
width, height = frame.shape
# Get the brightness
brightness = frame.mean()
if i > 0 and i < 2:
w, h = fgmask.shape
diff = np.count_nonzero(fgmask) / (1.0 * w * h)
# Add new scene if big difference encountered
if diff > exp_avrg or (currentframe + self._skip_rate +
1) >= end:
if current_frame_start != currentframe:
avrg_brightness /= 1.0 * (currentframe -
current_frame_start) / (
self._skip_rate + 1)
scenes.append({
"end_frame": currentframe,
"max_bspeed": max_bspeed,
"avrg_bspeed": exp_avrg,
"max_brightness": max_brightness,
"avrg_brightness": avrg_brightness
})
# Reinitialize the scene fetures
exp_avrg = self._alpha * diff + (
1 - self._alpha) * exp_avrg
max_bspeed = 0
max_brightness = 0
avrg_brightness = 0
last_frame = frame
# Compute the frame features
max_bspeed = max(diff, max_bspeed)
# Compute the frame features
max_brightness = max(brightness, max_brightness)
avrg_brightness += brightness
i += 1
# Increment the frame index & skipping some
currentframe += self._skip_rate + 1
# Save the scenes
fr_start = 0
ret_scenes = []
for j in range(len(scenes)):
scene = scenes[j]
fr_end = scene["end_frame"]
duration = (fr_end - fr_start)
if duration > self._skip_rate:
scenes[j]["start_frame"] = fr_start
scenes[j]["start"] = fr_start / self.fps
scenes[j]["end"] = fr_end / self.fps
scenes[j]["duration"] = duration / self.fps
scenes[j]["position"] = fr_start / self.length
ret_scenes.append(scenes[j])
fr_start = fr_end
# Return the result in the queue
return (ret_scenes, first_frame, last_frame)
def __init__(self, learning_rate=-1):
self.mog = cv2.BackgroundSubtractorMOG()
self.mask = None
self.learning_rate = learning_rate
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v", "--video", help="path to the (optional) video file")
ap.add_argument("-b", "--buffer", type=int, default=64, help="max buffer size")
args = vars(ap.parse_args())
# if a video path was not supplied, grab the reference
# to the webcam
if not args.get("video", False):
camera = cv2.VideoCapture(0)
# otherwise, grab a reference to the video file
else:
camera = cv2.VideoCapture(args["video"])
fgbg = cv2.BackgroundSubtractorMOG(50, 1, 0.9, .1)
fgbg2 = cv2.BackgroundSubtractorMOG(50, 1, 0.9, .1)
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
#face_cascade = cv2.CascadeClassifier('body.xml')
#(grabbed, frame) = camera.read()
#frame = imutils.resize(frame, width=600)
#frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#oldframe=frame
# keep looping
while True:
# grab the current frame
(grabbed, frame) = camera.read()
import cv2
import numpy as np
import math
cap = cv2.VideoCapture(0)
fgbg = cv2.BackgroundSubtractorMOG(history=3,nmixtures=4,backgroundRatio=0.5, noiseSigma=0.01)
fbg = 0
while(cap.isOpened()):
ret, img = cap.read()
fbg = img
history = 3
fbg = fgbg.apply(img,learningRate=1.0/history)
cv2.imshow('test',fbg)
#Region inside which the hand is to be placed
cv2.rectangle(img,(0,0),(500,500),(0,255,0),0)
grey = fbg[200:500, 200:500]
crop_img =img[200:500, 200:500]
fbg_crop = fbg[200:500, 200:500]
grey = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
#grey = cv2.cvtColor(crop_img, cv2.COLOR_GRAY2BGR)
value = (35,35)
thresh1 =crop_img
blurred = cv2.GaussianBlur(grey, value, 0)
_, thresh1 = cv2.threshold(blurred, 200, 255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
