def get_codec(format):
if (format == 'avi' or '.avi'):
codec = cv.CV_FOURCC('D', 'I', 'V', 'X')
elif (format == 'ogg' or '.ogv' or 'ogg' or '.ogg'):
codec = cv.CV_FOURCC('t', 'h', 'e', 'o')
return codec
def __init__(self, threshold=70, showWindows=True):
self.writer = None
self.font = None
self.show = showWindows # Either or not show the 2 windows
self.frame = None
self.capture = cv.CaptureFromCAM(0)
self.frame = cv.QueryFrame(self.capture) # Take a frame to init recorder
self.frame=self.frame[1:100,540:640]
self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) # Gray frame at t-1
cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
# Will hold the thresholded result
self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U) # Gray frame at t
self.width = self.frame.width
self.height = self.frame.height
self.nb_pixels = self.width * self.height
self.threshold = threshold
self.trigger_time = 0 # Hold timestamp of the last detection
codec = cv.CV_FOURCC('M', 'J', 'P', 'G') # ('W', 'M', 'V', '2')
self.writer = cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H_%M_%S") + ".wmv", codec, 5,
cv.GetSize(self.frame), 1)
# FPS set to 5 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) # Creates a font
def makeVideo(imageList,
outputPath=defaultOutputFolder + str(int(time.time())) + '.avi',
fourcc=cv.CV_FOURCC('F', 'L', 'V', '1'),
fps=defaultFps,
frameSize=defaultFrameSize):
#print imageList
# create a video writer
# c.f. http://opencv.willowgarage.com/documentation/python/reading_and_writing_images_and_video.html
#fourcc=cv.FOURCC('P','I','M','1'), doesn't work?
#writer = cv.CreateVideoWriter(filename=outputFolder+inputDate+'_'+inputType+'.avi',
# fourcc=cv.FOURCC('F', 'L', 'V', '1'),
# fps=1, frame_size=(600,600), is_color=1)
#and write your frames in a loop if you want
# the above don't work. replace by the following.
# http://stackoverflow.com/questions/12290023/opencv-2-4-in-python-video-processing/12333066#12333066
time0 = time.time()
writer = cv2.VideoWriter(filename=outputPath,
fourcc=fourcc,
fps=fps,
frameSize=frameSize)
for frame in imageList:
#print frame
#cv.ShowImage(str(frame), frame)
#cv.WaitKey()
#cv.WriteFrame(writer, frame) #old writer replaced
writer.write(frame)
def main(inputDate=defaultDate,
inputType=defaultType,
inputFolder="",
outputFolder=defaultOutputFolder,
extensions=['.png', '.jpg'],
fps='',
frameSize=defaultFrameSize):
"""
USE:
main(inputDate=defaultDate, inputType=DefaultType, inputFolder="", outputFolder="")
WHERE:
defaultDate = '2013-07-12'
defaultType = 'charts'
OUTPUT:
out
"""
time0 = time.time()
if inputFolder == "":
inputFolder = "%s%s/%s/" % (dataRoot, inputType, inputDate)
#print inputFolder
imageList = loadImages(inputFolder=inputFolder, extensions=extensions)
if fps == '':
fps = len(imageList) / 10. # frames per sec = len(imageList)/10.
# - so that each day lasts 10 seconds
# no matter how many frames there are
makeVideo(imageList=imageList,
outputPath=outputFolder + inputDate + '_' + inputType + '.avi',
fourcc=cv.CV_FOURCC('F', 'L', 'V', '1'),
fps=fps,
frameSize=frameSize)
print outputFolder + inputDate + '_' + inputType
print time.time() - time0
def processGroup(self, framegroup):
'''
Writes frames from specified stream of framegroup to an AVI file using OpenCV
@param framegroup: the incoming framegroup object
'''
if framegroup is not None:
ext = "avi"
codec = "DIVX"
# calculate details
fps = int(
round(
len(framegroup) /
(framegroup[-1].timestamp - framegroup[0].timestamp)))
f0 = framegroup[0][self._stream].asQImage()
fsize = (f0.width(), f0.height())
filename = framegroup.filename
if filename is None:
filename = "%s%svideo_%s" % (
self._recorddirectory,
os.path.sep,
time.strftime("%Y-%m-%d_%H-%M-%S"),
)
filename += ".%s" % ext
# open writer
writer = cv2.VideoWriter(filename, cv.CV_FOURCC(*codec), fps,
fsize)
# write frame files
for frameset in framegroup:
frame = self._QImageToCv(frameset[self._stream].asQImage())
writer.write(frame)
def initRecorder(self): #Create the recorder
codec = cv.CV_FOURCC('M', 'J', 'P', 'G') #('W', 'M', 'V', '2')
now = datetime.now().strftime("%b-%d_%H%M%S")
print now + ".wmv"
self.writer=cv.CreateVideoWriter( now +".wmv", codec, 5, cv.GetSize(self.frame), 1)
#FPS set to 5 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) #Creates a font
def initGrab(self):
image = ImageGrab.grab(self.geometry)
cv_im = cv.CreateImageHeader(image.size, cv.IPL_DEPTH_8U, 3)
cv.SetData(cv_im, image.tostring())
cv.CvtColor(cv_im, cv_im, cv.CV_RGB2BGR)
fourcc = cv.CV_FOURCC('D','I','V','X')
fps = 25
width, height = cv.GetSize(cv_im)
#print width, height
self.writer = cv.CreateVideoWriter('out3.avi', fourcc, fps, (int(width), int(height)), 1)
cv.WriteFrame(self.writer, cv_im)
self.frames_count = 1
timer = QtCore.QTimer()
time_interval = 1000 / 25
timer.setInterval(time_interval)
timer.timeout.connect(self.grabFrame)
timer.start()
self.timer = timer
self.stopTimer = QtCore.QTimer()
self.stopTimer.setInterval(self.total_time)
self.stopTimer.timeout.connect(self.stopCapture)
self.stopTimer.setSingleShot(True)
self.stopTimer.start()
def initGrabQt(self):
image_qt = QtGui.QPixmap.grabWidget(self.view).toImage()
image_qt_size = (image_qt.size().width(), image_qt.size().height())
cv_im_4chan = cv.CreateImageHeader(image_qt_size, cv.IPL_DEPTH_8U, 4)
cv_im = cv.CreateImage(image_qt_size, cv.IPL_DEPTH_8U, 3)
cv.SetData(cv_im_4chan, image_qt.bits().asstring(image_qt.numBytes()))
cv.CvtColor(cv_im_4chan, cv_im, cv.CV_RGBA2RGB)
fourcc = cv.CV_FOURCC('D','I','V','X')
fps = 25
width, height = cv.GetSize(cv_im)
self.writer = cv.CreateVideoWriter('out3.avi', fourcc, fps, (int(width), int(height)), 1)
cv.WriteFrame(self.writer, cv_im)
timer = QtCore.QTimer()
time_interval = 1000 / 25
timer.setInterval(time_interval)
timer.timeout.connect(self.grabFrameQt)
timer.start()
self.timer = timer
self.stopTimer = QtCore.QTimer()
self.stopTimer.setInterval(self.total_time)
self.stopTimer.timeout.connect(self.stopCapture)
self.stopTimer.setSingleShot(True)
self.stopTimer.start()
def save_video(video, fps, save_filename='media/output.avi'):
"""Save a video to disk"""
fourcc = cv.CV_FOURCC('M', 'J', 'P', 'G')
writer = cv2.VideoWriter(save_filename, fourcc, fps,
(video.shape[2], video.shape[1]), 1)
for x in range(0, video.shape[0]):
res = cv2.convertScaleAbs(video[x])
writer.write(res)
def initRecorder(self): #Create the recorder
codec = cv.CV_FOURCC('D', 'I', 'V', 'X') #('W', 'M', 'V', '2')
self.writer = cv.CreateVideoWriter(
datetime.now().strftime("%b-%d_%H_%M_%S") + ".avi", codec, 20,
cv.GetSize(self.frame), 1)
#FPS set to 20 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2,
8) #Creates a font
def __init__(self, srcFilePath, destFilePath, bgStart, nBackgroundFrames,
cropParams, scaleParams):
RecordedVideoStream.__init__(self, srcFilePath, bgStart,
nBackgroundFrames)
self.cropParams = np.array(cropParams)
self.scaleParams = np.array(scaleParams)
size = self.getFinalSize()
self.videoWriter = cv2.VideoWriter(destFilePath, cv.CV_FOURCC(*'mp4v'),
self.fps, size[::-1], True)
def writeVideo(self):
height,width=cv2.imread("Frames/1.jpg").shape[:2]
out = cv2.VideoWriter("changedOutput.ogv",cv.CV_FOURCC('t','h','e','0'), 25.0, (width,height))
folder=self.sort_files()
for i in folder:
pic="Frames/"+str(i)+".jpg"
img=cv2.imread(pic)
out.write(img)
out.release()
def begin(self, image):
now = time.time()
if not self.mp4:
# 'M', 'J', 'P', 'G'
self.mp4 = cv2.VideoWriter("tmp.avi",
cv.CV_FOURCC('M', 'J', 'P', 'G'),
self.fps, self.size, 1)
self.begin_record_at = now
self.record(image, now)
self.last_record_at = now
def initRecorder(self): # Create the recorder
codec = cv.CV_FOURCC('M', 'J', 'P', 'G')
self.writer = cv.CreateVideoWriter(
datetime.now().strftime("%Y%m%d_%H%M%S") + ".wmv", codec, 8,
cv.GetSize(self.frame), 1)
# FPS set to 30 because it seems to be the fps of my cam but should be ajusted to your needs
self.countdownFont = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 3, 3, 0,
5, 8) # Creates a font
self.timeFont = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2,
8) # Creates a font
def _init_writer(self):
#dest = self.DIR + strftime('%yy_%mm_%dd_%Hh_%Mm_%Ss_') + key + '.avi'
dest = '{dir}{timestamp}{name}.avi'.format(
dir=self.DIR,
timestamp=strftime('%yy_%mm_%dd_%Hh_%Mm_%Ss_'),
name=self._settings['name'])
self._writer = cv2.VideoWriter()
self._writer.open(filename=dest,
fourcc=cv.CV_FOURCC(*list('MJPG')),
fps=5,
frameSize=(640, 480))
def __init__(self, fp):
"""
Initialize with filepath to .avi file you want to alter.
"""
self._fps = 23.92
self._capture_size = (1920, 1080)
self._fourcc = cv.CV_FOURCC('m', 'p', '4', 'v')
self._directory = os.path.split(fp)[0]
self._file_name = os.path.splitext(os.path.split(fp)[1])[0]
self._file_ext = os.path.splitext(os.path.split(fp)[1])[1]
self._capture = video.create_capture(fp)
def writeOutputFile(self, output):
self.height, self.width = cv2.imread("Frames/1.jpg").shape[:2]
out = cv2.VideoWriter(output, cv.CV_FOURCC('a', 'v', 'c', '1'), 30.0,
(self.width, self.height))
folder = self.sort_files()
for i in folder:
pic = "Frames/" + str(i) + ".jpg"
img = cv2.imread(pic)
out.write(img)
out.release()
def recordkinect1():
# record depth
code = cv.CV_FOURCC('m','p','4','v')
depth = cv2.VideoWriter()
success = depth.open('depth.mp4',code,10,(640,480),True)
old_time = time.time()
while time.time() - old_time < 30:
dep = get_depth1()
image = cv2.cvtColor(dep,cv2.COLOR_GRAY2BGR)
depth.write(image)
cv2.waitKey(10)
depth.release()
def writeOutputFile(self):
self.height, self.width = cv2.imread(
"/Users/pratikramdasi/Desktop/frames/0 (1).jpg").shape[:2]
out = cv2.VideoWriter("/Users/pratikramdasi/Desktop/vtest.mp4",
cv.CV_FOURCC('a', 'v', 'c', '1'), 30.0,
(self.width, self.height))
folder = self.sort_files()
for i in folder:
pic = "/Users/pratikramdasi/Desktop/frames/0 (" + str(i) + ").jpg"
img = cv2.imread(pic)
out.write(img)
out.release()
def recordkinect2():
# record vid and depth side by side
code = cv.CV_FOURCC('m','p','4','v')
dual = cv2.VideoWriter()
success = dual.open('dual.mp4',code,10,(1280,480),True)
old_time = time.time()
while(time.time()-old_time<60):
dep = get_depth1()
vid = get_video1()
depth = cv2.cvtColor(dep,cv2.COLOR_GRAY2BGR)
output = np.zeros((480, 640*2, 3), dtype="uint8")
output[0:480,0:640] = vid
output[0:480,640:1280] = depth
# cv2.imshow('lol',output)
dual.write(output)
dual.release()
def recordkinect():
# record video
code = cv.CV_FOURCC('m','p','4','v')
# depth = cv2.VideoWriter()
vid = cv2.VideoWriter()
# success = depth.open('depth.mp4',code,10,(640,480),False)
success2 = vid.open('video.mp4',code,10,(640,480),True)
old_time = time.time()
while time.time()-old_time < 30:
print(old_time)
vid.write(get_video1())
# depth.write(get_depth1())
cv2.waitKey(10)
print(time.time())
# depth.release()
vid.release()
def __init__(self,
fName,
size=None,
fps=25,
isColor=True,
fourcc=cv.CV_FOURCC(*'MJPG')): #('X','V', 'I', 'D')):
self.fileName = fName
self.width = -1
self.height = -1
self.frames = 0
self.fps = fps
self.aviHandler = None
self.fourcc = fourcc
self.isColor = isColor
self.size = size
def _startVideoCaptureSession(self, filePath): # TODO: refactor name
"""
Initiates a cv2.VideoCapture object to supply the frames to read
and a cv2.VideoWriter object to save a potential output
:param str filePath: the source file path
:return: capture and videoWriter object
:rtype: (cv2.VideoCapture, cv2.VideoWriter)
"""
capture = cv2.VideoCapture(filePath)
dirname, filename = os.path.split(filePath)
basename, ext = os.path.splitext(filename)
savePath = os.path.join(dirname, 'recording.avi') # Fixme: should use argument
videoWriter = cv2.VideoWriter(savePath, cv.CV_FOURCC(*'mp4v'), 15, self.size, True)
if not(videoWriter.isOpened()):
raise VideoStreamIOException("Can't start video writer codec {} probably unsupported".format(CODEC))
return capture, videoWriter
def combine_pyramid_and_save(g_video,
orig_video,
enlarge_multiple,
fps,
save_filename='media/output.avi'):
"""Combine a gaussian video representation with the original and save to file"""
width, height = get_frame_dimensions(orig_video[0])
fourcc = cv.CV_FOURCC('M', 'J', 'P', 'G')
writer = cv2.VideoWriter(save_filename, fourcc, fps, (width, height), 1)
for x in range(0, g_video.shape[0]):
img = numpy.ndarray(shape=g_video[x].shape, dtype='float')
img[:] = g_video[x]
for i in range(enlarge_multiple):
img = cv2.pyrUp(img)
img[:height, :width] = img[:height, :width] + orig_video[x]
res = cv2.convertScaleAbs(img[:height, :width])
writer.write(res)
def makeVideoAll(inputType=defaultType,
inputFolder="",
extensions=['.png', '.jpg'],
outputFolder="",
fourcc=cv.CV_FOURCC('F', 'L', 'V', '1'),
fps=defaultFps,
frameSize=defaultFrameSize):
"""
cd /media/KINGSTON/ARMOR/python/
python
from armor.video import makeVideo as mv
reload(mv) ; mv.makeVideoAll(inputType="charts2")
"""
time0 = time.time()
if inputFolder == "":
inputFolder = "%s%s/" % (dataRoot, inputType)
if outputFolder == "":
outputFolder = defaultOutputFolder + inputType + '_' + str(
int(time.time())) + '/'
#debug
print inputFolder
os.makedirs(outputFolder)
LL = os.listdir(inputFolder)
LL.sort()
for folder in LL:
imageList = loadImages(inputFolder=inputFolder + folder + '/',
extensions=extensions)
try:
print folder
makeVideo(
imageList,
outputPath=outputFolder + folder + '_' + inputType + '.avi',
fourcc=fourcc,
fps=len(imageList),
#fps = len(imageList)/10. ,
frameSize=frameSize) # frames per sec = len(imageList)/10.
# - so that each day lasts 10 seconds
# no matter how many frames there are
except:
print folder, "makeVideo ERROR!!!!!!!!!!!" # don't care if it doesn't work
time.sleep(3)
print time.time() - time0
def RecordVideoFromCamera():
cap = cv2.VideoCapture(0)
f,I = cap.read()
print I.shape
H,W,Z=I.shape
writer = cv2.VideoWriter('Pattern.avi', cv.CV_FOURCC('D','I','V','X'), 10.0, (W,H), True)
cv2.namedWindow("input")
while(f):
f,I = cap.read()
if f==True:
writer.write(I)
cv2.imshow("input", array(I))
ch = cv2.waitKey(1)
if ch == 32 or ch == 27:# Break by SPACE key
break
writer.release()
def initRecorder(self): #Create the recorder
codec = cv.CV_FOURCC('M', 'J', 'P', 'G')
self.writer = cv.CreateVideoWriter(
datetime.now().strftime("/home/pi/python_programs/camera_output/" +
"%b-%d_%H_%M_%S") + ".wmv", codec, 5,
cv.GetSize(self.frame), 1)
#FPS set to 5 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2,
8) #Creates a font
# Comments:
""" By changing threshold in def __init__(..,self.threshold = 15,...) you control sensitivity of image capture"""
"""e.g threshold = 15 is more sensitive in threshold = 25"""
# end
self.captureCounter += 1
img = cv.QueryFrame(self.capture)
filename = "capture" + str(self.captureCounter)
file = "/home/pi/python_programs/camera_output/" + filename + ".png"
cv.SaveImage(file, img)
def recordwebcam():
cap = cv2.VideoCapture(0)
code = cv.CV_FOURCC('m','p','4','v')
out = cv2.VideoWriter()
succes = out.open('output.mp4',code, 10, (1280,720),True)
while(cap.isOpened()):
ret, frame = cap.read()
if ret==True:
frame = cv2.flip(frame,180)
# write the flipped frame
out.write(frame)
cv2.imshow('frame',frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
else:
break
# Release everything if job is finished
cap.release()
out.release()
cv2.destroyAllWindows()
def applyTransform(self):
self.framing(self.path)
self.height, self.width = cv2.imread("Frames/1.jpg").shape[:2]
# write transformed video
out = cv2.VideoWriter("changedOutput.mp4",
cv.CV_FOURCC('a', 'v', 'c', '1'), 30.0,
(self.width, self.height))
folder = self.sort_files()
# write Transformed video frames
for i in folder:
pic = "Frames/" + str(i) + ".jpg"
Newpic = cv2.imread(pic, 0)
frame = cv2.Canny(Newpic, 100, 200)
cv2.imwrite(pic, frame)
Newpic = cv2.imread(pic)
img = cv2.flip(Newpic, 0)
out.write(img)
out.release()
def normalize_video_lenght(i_name, o_name, fps, length, verbose=False):
capture = cv.CaptureFromFile(i_name)
width = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH))
height = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT))
original_fps = cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FPS)
original_frames_number = cv.GetCaptureProperty(capture,
cv.CV_CAP_PROP_FRAME_COUNT)
final_frames_number = int(fps * length)
if verbose:
print '\ninput video: ', i_name
print 'size: %s:%s' % (width, height), ' fps:', original_fps, 'frames:', \
original_frames_number, 'estimated length:', float(original_frames_number)/original_fps
print '\noutput video: ', o_name
print 'size: %s:%s' % (width, height), ' fps:', fps, 'frames:', \
final_frames_number, 'estimated length:', float(final_frames_number)/fps, '\n'
my_fourcc = cv.CV_FOURCC('m', 'p', 'g', '2')
writer = cv.CreateVideoWriter(o_name, my_fourcc, fps, (width, height))
diff = final_frames_number - original_frames_number
step = operation = None
if diff > 0:
step = int(original_frames_number / diff)
operation = expand_video
elif diff < 0:
step = int(final_frames_number / abs(diff))
operation = reduce_video
if step == 0:
print 'The desired final length is too short'
return 1
result = operation(capture, writer, final_frames_number, step, verbose)
if verbose:
print 'A total of', result, 'frames were removed/duplicated from the original video.'
return 0
