def addFrame(self, img): ''' @param img: A pyvision img to write out to the video. ''' if self._no_annotations: img2 = img else: img2 = pv.Image(img.asAnnotated()) if self._bw: cv.WriteFrame(self._out, img2.asOpenCVBW()) else: cv.WriteFrame(self._out, img2.asOpenCV())
def image_handler(self, data): """ Writes frames to avi file. """ if self.framerate is not None: # Convert to opencv image and then to ipl_image cv_image = self.bridge.imgmsg_to_cv(data, 'bgr8') ipl_image = cv.GetImage(cv_image) cv_image_size = cv.GetSize(cv_image) if self.frame_count == 0: self.cv_image_size = cv_image_size self.start_video_writer() if cv_image_size != self.cv_image_size: # Abort recording - image size changed. pass if self.recording: # Write video frame cv.WriteFrame(self.writer, ipl_image) self.frame_count += 1 else: stamp = data.header.stamp if self.last_stamp is not None: diff_stamp = stamp - self.last_stamp dt = diff_stamp.to_sec() self.framerate = 1 / dt self.last_stamp = stamp
def image_handler(self, data): """ Writes frames to avi file. """ self.current_t = rospy.get_time() # Convert to opencv image and then to ipl_image cv_image = self.bridge.imgmsg_to_cv(data, 'bgr8') ipl_image = cv.GetImage(cv_image) with self.lock: if self.cv_image_size == None: self.cv_image_size = cv.GetSize(cv_image) if not self.done: # Write video frame cv.WriteFrame(self.writer, ipl_image) # Update times and frame count - these are used elsewhere so we # need the lock with self.lock: self.frame_count += 1 self.progress_t = self.current_t - self.start_t # Publish progress message with self.lock: self.progress_msg.frame_count = self.frame_count self.progress_msg.progress_t = self.progress_t self.progress_msg.recording_message = self.recording_message self.progress_pub.publish(self.progress_msg)
def write_frame(self, img): """ Write a frame to our video """ self.frame_num += 1 # cv.SaveImage("testimage%d.jpg" % self.frame_num, img) cv.WriteFrame(self._vidWriter, img)
def VideoStream(): """ VideoStream should probably be updated to utilized the cv2 python wrapper for opencv If you're having problems, remember to check the camera index, fps """ global Finished #display live video cv.NamedWindow("Badass video window", cv.CV_WINDOW_AUTOSIZE) #peripheral devices begin at > 0 global camera_index capture = cv.CaptureFromCAM(camera_index) frame = cv.QueryFrame(capture) writer = cv.CreateVideoWriter( "Stream.avi", 0, 20, cv.GetSize(frame), 1) #"filename", codec,fps, frame_size, is_color=true #isight can't handle 30 fps so changed it to 15 print "Calling thread at: ", time.time() Thread(target=AudioStream).start() i = 1 while True: print "Recording Video Frame: ", i, " At: ", time.time() frame = cv.QueryFrame(capture) cv.WriteFrame(writer, frame) cv.ShowImage("Badass video window", frame) k = cv.WaitKey(10) #milliseconds i += 1 if k == 0x1b: #ESC print 'ESC pressed. Exiting ... Time is: ', time.time() break Finished = True cv.DestroyWindow("Baddass video window") sys.exit(1) return
def Cam_Video(self): # Recebe uma imagem e manda mostrar na tela Actions.Receive_File() if (self.ui.Record_Button.isFlat()): frame = cv.LoadImage("img/img.jpg") cv.WriteFrame(self._writer, frame) self.Image_Show("img/img.jpg")
def convert2vid(bdjoints, fimgs, fps, Vtype=0): # Vtype : 0 : color m, 1: depth ,2: body index if Vtype == 0: fsize = (1920, 1080) extname = '' elif Vtype == 1: fsize = (512, 424) extname = 'dp' else: fsize = (512, 424) extname = 'bdidx' #now = datetime.datetime.now() vid = 'kinect' + repr(now.month).zfill(2) + repr(now.day).zfill(2) + repr( now.hour).zfill(2) + repr(now.minute).zfill(2) + '_' + extname + '.avi' video = cv.CreateVideoWriter(vid, cv.CV_FOURCC('L', 'A', 'G', 'S'), fps, fsize, True) print 'making video .....' for i in fimgs: bitmap = cv.CreateImageHeader(fsize, cv.IPL_DEPTH_8U, 3) cv.SetData(bitmap, i.tostring(), i.dtype.itemsize * 3 * i.shape[1]) cv.WriteFrame(video, bitmap) print 'there r total ' + repr(len(fimgs)) + ' frames' del video
def write_send(camera, im, writer, s): try: # print "Sending %f " % time.time() s.send(('%f ' % time.time()).encode('latin-1')) except: pass cv.WriteFrame(writer, im)
def DisplayWriteFrame(image): cv.ShowImage('Image_Window', image) i = 0 while i < 15: cv.WriteFrame(writer, image) i += 1 cv.WaitKey(1000)
def mergeImageFilesToVideo(directory, outputFile="merge.avi", resolution=None, recurse=False): """ Scan all files present in the specified directory and sort alphabetically. Look at each file in order and if the file has an image extension (bmp, jpg, png) supported by OpenCV, then open it and append the image to an output video file. If the resolution parameter is None then set the output video resolution to be the resolution of the first image file detected and resize subsequent image files to this size. @param directory: absolute directory location to scan. @param outputFile: name of the output video file to create. @param resolution: the output resolution to use for the video, if None then auto-detect based on first read image file. @param recurse: if true then recurse into all subdirectories and perform the same task to create one video file per directory containing images. """ print "Check Dir: ",directory if not os.path.isdir(directory): raise RuntimeError("The path is not a valid directory.") cvImg = None videoWriter = None for file in os.listdir(directory): absFile = directory+file #print absFile ex = file[-4:] if os.path.isdir(absFile): if recurse: mergeImageFilesToVideo(absFile+os.sep, recurse=True) elif ex==".bmp" or ex==".jpg" or ex==".png": img = cv.LoadImage(absFile, cv.CV_LOAD_IMAGE_GRAYSCALE) if img==None: continue #TODO: what is img set to if file is not valid image? (None?) if resolution==None: resolution = (img.width, img.height) if resolution[0]<64 or resolution[1]<64: resolution = (64,64) if videoWriter==None: outDir = DESTDIR+directory[len(ROOTDIR):].replace(os.sep, "_") print outDir+outputFile videoWriter = cv.CreateVideoWriter(outDir+outputFile, cv.CV_FOURCC('I','Y','U','V'), \ 15, resolution, 0) if cvImg==None: cvImg = cv.CreateImage(resolution, cv.IPL_DEPTH_8U, 1) cv.Resize(img, cvImg) cv.WriteFrame(videoWriter, cvImg) if videoWriter!=None: del videoWriter
def write(self, image): """ Write frame. cv_image (IplImage): Destination image. """ if not self.writer: if not self.size: self.size = cv.GetSize(image) self.writer = cv.CreateVideoWriter(self.destination, self.codec, self.framerate, self.size, 1) cv.WriteFrame(self.writer, image); self.frame_num += 1
def write_video(vid_arr, filename, fps=10, h5input=False, fourcc=None): """ Writes video to the specified filename parameters: vid_arr: A numpy array, GPUArray or PitchArray representing the video filename: The output filename fps: The frame rate of the output video If not specified, will be set to 10. h5input: True if vid_arr is a filename of an h5 file containg the video. If not specified, will be set to False. fourcc: An integer representing the codec to be used for the video file. Can be specified using cv.CV_FOURCC. If not specified, will default to DIVX. """ if (not (CV_INSTALLED)): raise ImportError("Failure to load OpenCV.\n \t " \ "write_video requires: OpenCV\n") if (h5input): vid_arr = io.read_file(vid_arr) else: if PYCUDA: if vid_arr.__class__.__name__ in ["GPUArray", "PitchArray"]: vid_arr = vid_arr.get() elif vid_arr.__class__.__name__ != "ndarray": raise TypeError("Write video error: Unknown input type") elif vid_arr.__class__.__name__ != "ndarray": raise TypeError("Write video error: Unknown input type") height = vid_arr.shape[1] width = vid_arr.shape[2] if vid_arr.min() < 0: vid_arr = vid_arr - vid_arr.min() if vid_arr.max() > 1: vid_arr = vid_arr / vid_arr.max() if len(vid_arr.shape) == 3: temp = vid_arr vid_arr = np.zeros((temp.shape[0], height, width, 3)) for i in range(3): vid_arr[:, :, :, i] = 255 * temp[:, :, :] del temp vid_arr = vid_arr.astype('uint8') if fourcc is None: fourcc = cv.CV_FOURCC('D', 'I', 'V', 'X') writer = cv.CreateVideoWriter(filename, fourcc, fps, (width, height), 1) for i in xrange(vid_arr.shape[0]): cv.WriteFrame(writer, array2cv(vid_arr[i, :, :, :]))
def record(self): self.stan = 1 while self.stan: original = cv.QueryFrame(self.capture) size = cv.GetSize(original) cv.ShowImage('Camera picture - PRESS ESC TO EXIT', original) k = cv.WaitKey(33) if k == 0x1b: # ESC print 'ESC pressed. Exiting ...' break cv.WriteFrame(self.writer, original) #cv.ReleaseCapture(self.capture) cv.cvReleaseVideoWriter(self.writer)
def generateVideoClip(videoDir="./video/"): """ Generate a simple example black and white video clip that can be used as input to the Camera Toolkit for performing basic experiments. By default the method is writing a video file consisting of a horizontal white line against a black background. The line moves from top to bottom and back again 1 pixel at a time. The code can be edited by changing the looping parameters on line 46 and what is painted per frame on line 53. @param videoDir: the directory the video will be created in. """ suffix = "Rectangle17.avi" #edit this for different file names fileName = videoDir+suffix width = 80 #the Region prefers 80x60 resolution video frames height = 60 #Create a videoWriter to use to write out the generated video file #Always use uncompressed YUV codec for universal playback #method doc: CreateVideoWriter(filename, fourcc, fps, frame_size, is_color) videoWriter = cv.CreateVideoWriter(fileName, cv.CV_FOURCC('I','Y','U','V'), \ 15, (width,height), 0) #Allocate a PIL image to paint into for each video frame vidFrame = Image.new('L', (width,height)) print "writing video",fileName #Each pass in this loop will generate a subsequent video frame #For a horizontal line, loop from top to bottom, and back again for x in range(8,width-25): #for y in xrange(15,height-15): #for i in range(0,height)+range(height-2,-1,-1): #fill frame with black, then draw white lines/dots for the frame draw = ImageDraw.Draw(vidFrame) draw.rectangle((0,0, width,height), fill="black") #now that frame is black again, draw a white line in current position #draw.line((0,i,width,i), fill="white", width=1) draw.rectangle((x,x, x+17,x+17), outline="white") #we could do other things here instead, such as drawing points: #draw.point((x,y), fill="white") del draw #done performing drawing for this frame #now convert the PIL image into an OpenCV image and write to video cvImage = cv.CreateImageHeader(vidFrame.size, cv.IPL_DEPTH_8U, 1) cv.SetData(cvImage, vidFrame.tostring()) cv.WriteFrame(videoWriter, cvImage) del videoWriter #close video stream when done to finish file return suffix #return fileName suffix as indicator of success
def run(self): fps = 30 frame = cv.QueryFrame(self.capture) frame_size = cv.GetSize(frame) writer = cv.CreateVideoWriter('movie.avi', cv2.cv.CV_FOURCC('F', 'M', 'P', '4'), fps, frame_size) while True: frame = cv.QueryFrame(self.capture) cv.ShowImage("CamShiftDemo", frame) c = cv.WaitKey(7) cv.WriteFrame(writer, frame) if c == 27: break cv.ReleaseVideoWriter(writer)
def find_fish(file_name,num_filters,input_file): finder = FishFinder(file_name,num_filters) capture_file = cv.CreateFileCapture(input_file) output_file = get_output_name(input_file) loop = True frame = cv.QueryFrame(capture_file) video_writer = cv.CreateVideoWriter(output_file,cv.CV_FOURCC('P','I','M','1'),27.96,cv.GetSize(frame),1) while(loop): if (frame == None): print "no frame"; exit() #annotated_frame = finder.find_fish(frame) annotated_frame = finder.get_annotated_image(frame) cv.WriteFrame(video_writer,annotated_frame)#cvHelper.gray_colour_image(annotated_frame)) frame = cv.QueryFrame(capture_file)
def convert2othvid(self, string, imgs): now = datetime.datetime.now() vid = string + repr(now.month).zfill(2) + repr( now.day).zfill(2) + repr(now.hour).zfill(2) + repr( now.minute).zfill(2) + '.avi' video = cv.CreateVideoWriter(vid, cv.CV_FOURCC('L', 'A', 'G', 'S'), fps, (512, 424), True) #st = time.clock() #pdb.set_trace() print 'making video .....' for i in imgs: bitmap = cv.CreateImageHeader((512, 424), cv.IPL_DEPTH_8U, 3) cv.SetData(bitmap, i.tostring(), i.dtype.itemsize * 3 * i.shape[1]) cv.WriteFrame(video, bitmap) #print time.clock()-st print 'there r total ' + repr(len(fimgs)) + ' frames' del video
def find_position(self): print "Kinect is trying to find the image" (kinect_depth,_), (rgb,_) = get_depth(), get_video() self.img = video_cv(rgb) depth_img = pretty_depth_cv(kinect_depth) position = self._get_pos(self.img) depth = self._get_depth(depth_img, debug=False) font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 1, 1) fps = 1/(time.time() - self.lasttime) s1 = "FPS:%.2f" % fps self.lasttime = time.time() cv.PutText(self.img,s1, (0,30),font, cv.CV_RGB(255, 0, 0)) dt = "Depth: %d" % depth if position: pt = "Pos: X=%d Y=%d" % (position[0], position[1]) else: pt = "Pos: N/A" cv.PutText(self.img, dt, (0,60),font, cv.CV_RGB(255, 0, 0)) cv.PutText(self.img, pt, (0,90),font, cv.CV_RGB(255, 0, 0)) offset = 120 for t in self.text: cv.PutText(self.img, t, (0,offset),font, cv.CV_RGB(255, 0, 0)) offset += 30 cv.Circle(self.img, (self.sp[0], self.sp[1]) , 10, cv.CV_RGB(0, 255, 0), 1) cv.ShowImage('RGB', self.img) #cv.SaveImage('RGB-%d.png' % (time.time()*100), self.img) #cv.ShowImage('DEPTH', depth_img) cv.WriteFrame(self.writer, self.img) cv.WaitKey(5) #cv.ShowImage('depth_mask', depth_mask) try: return (position[0], position[1], depth) except: return (None, None, None)
def create_v(frames, path): #fourcc = cv2.VideoWriter_fourcc(*'XVID') '''fourcc = cv.CV_FOURCC('i','Y', 'U', 'V') frame=cv.LoadImage(path+"/"+frames[2]) frame_size = cv.GetSize(frame) print "Video size: ", frame_size out=cv2.VideoWriter('output.avi',fourcc,1.0,frame_size) for i in frames: path1=path+i print path1 img=cv2.imread(path1) s="./output/"+i[:-4]+".png" print s cv2.imwrite(s,img) out.write(img) out.release()''' frame = cv.LoadImage(path + "/" + frames[2]) print dir(frame) fps = 1.0 # so we need to hardcode the FPS print "Recording at: ", fps, " fps" frame_size = cv.GetSize(frame) print "Video size: ", frame_size CODEC = cv.CV_FOURCC('D', 'I', 'V', '3') # MPEG 4.3 # CODEC = cv.CV_FOURCC('M','P','4','2') # MPEG 4.2 # CODEC = cv.CV_FOURCC('M','J','P','G') # Motion Jpeg # CODEC = cv.CV_FOURCC('U','2','6','3') # H263 # CODEC = cv.CV_FOURCC('I','2','6','3') # H263I # CODEC = cv.CV_FOURCC('F','L','V','1') # FLV CODEC = cv.CV_FOURCC('P', 'I', 'M', '1') # MPEG-1 CODEC = cv.CV_FOURCC('D', 'I', 'V', 'X') # MPEG-4 = MPEG-1 writer = cv.CreateVideoWriter(path + "/out.avi", CODEC, fps, frame_size, True) for i in frames: path1 = path + "/" + i print path1 img = cv.LoadImage(path1) cv.WriteFrame(writer, img)
def main_loop(self): presentation = [] self.orig = cv.QueryFrame(self.capture) #cv.PyrDown( self.orig, self.small, 7 ) # CV_GAUSSIAN_5x5 = 7 cv.Resize(self.orig, self.small) cv.CvtColor(self.small, self.bw, cv.CV_BGR2GRAY) cv.CvtColor(self.small, self.hsv, cv.CV_BGR2HSV) cv.Split(self.hsv, self.hue, self.sat, self.val, None) cv.Copy(self.small, self.visualize) presentation.append(self.visualize) # presentation.append(self.hue) # presentation.append(self.sat) face = self.find_face(self.small) if face: self.update_histogram(face) bp = self.backproject() scaled = self.scale(bp) # presentation.append(scaled) th = self.threshold(scaled) # presentation.append(th) morphed = self.morphology(th) cv.Zero(self.result) cv.Copy(self.small, self.result, morphed) contours = self.find_contours(morphed) self.draw_contours(self.result, contours) limbs = self.find_limbs(contours) presentation.append(self.result) # combine and show the results combined = self.combine_images(presentation) cv.ShowImage('Skin Detection', combined) if STORE: cv.WriteFrame(self.writer, self.combined)
def save_movie(self): """ Creates a movie with all faces found in the inputs. Guy is skipped if no face is found. :param out_folder: the location where to save the output image. :type out_folder: string :param fps: the number of frames per second to be displayed in final video (3) :type fps: int """ speedrate = self.face_params.speed if "win" in sys.platform: fourcc = cv.CV_FOURCC('C', 'V', 'I', 'D') else: # some kind of Linux/Unix platform fourcc = cv.CV_FOURCC('F', 'M', 'P', '4') # Corrects frameSize to get a nice video output frameSize = self.resizes_for_video_codec( ) # Fixme : Put in global parameter # We have to resize the out_image to make them fit with the desired size corr_im = cv.CreateImage(frameSize, self.depth, self.nChannels) #frameSize = (652, 498) pace = ["slow", "normal", "fast"] my_video = cv.CreateVideoWriter(self.get_out_file(), fourcc, self.speed[speedrate], frameSize, 1) ii = 0 for a_guy in self.guys: if self.run: ii += 1 self.notify_progress("Saving frame", ii, self.number_guys()) #self.console_logger.info("Saving frame %d / %d" % (ii, self.number_guys())) self.my_logger.info("Saving frame %d / %d" % (ii, self.number_guys())) out_im = self.prepare_image(a_guy) cv.Resize(out_im, corr_im, cv.CV_INTER_LINEAR) cv.WriteFrame(my_video, corr_im)
def captureFromCamera(self): """ Capture a live frame from the camera and perform motion processing on the acquired image. If recording is enabled, also write the processed frame to an output video file. """ frame = cv.QueryFrame(self._capture) # Grab the frame from the capture if not frame: self.stopRun() return None frameOut = self.__processVideoFrame(frame) # Mirror if using camera, this is more intuitive for webcams frameOut = ImageOps.mirror(frameOut) if self._videoWriter: #if recording enabled, write out to the video file cvImage = Util.convertPILToCV(frameOut) cv.WriteFrame(self._videoWriter, cvImage) return frameOut
def nextFrame(self): if self.writer == None: four_cv = cv.CV_FOURCC(self.codec[0], self.codec[1], self.codec[2], self.codec[3]) self.writer = cv.CreateVideoWriter(self.fn, four_cv, self.fps(), (self.width(), self.height()), 1) frame = self.video.fetch(self.channel) mode = self.video.outputMode(self.channel) frame = (frame * 255.0).astype(numpy.uint8) if mode == MODE_RGB: out = array2cv(frame[:, :, ::-1]) elif mode == MODE_FLOAT: out = array2cv(frame) else: raise Exception('Unsuported mode for WriteCV') cv.WriteFrame(self.writer, out) return True
def image_handler(self,data): """ Writes frames to avi file. """ self.current_t = rospy.get_time() # Convert to opencv image and then to ipl_image cv_image = self.bridge.imgmsg_to_cv(data,'bgr8') ipl_image = cv.GetImage(cv_image) with self.lock: if self.cv_image_size == None: self.cv_image_size = cv.GetSize(cv_image) if not self.done: # Write video frame cv.WriteFrame(self.writer,ipl_image) # Update times and frame count - these are used elsewhere so we # need the lock with self.lock: self.frame_count += 1 self.progress_t = self.current_t - self.start_t # Check to see if we are done recording - if so stop writing frames if self.current_t >= self.start_t + self.record_t: self.done = True del self.writer self.writer = None self.recording_message = 'finished' db_tools.set_bool(self.redis_db,'recording_flag',False) # Publish progress message with self.lock: self.progress_msg.frame_count = self.frame_count self.progress_msg.record_t = self.record_t self.progress_msg.progress_t = self.progress_t self.progress_msg.recording_message = self.recording_message self.progress_pub.publish(self.progress_msg)
def pipeline(self): presentation = [] self.orig = self.source.grab_frame() cv.Resize(self.orig, self.small) size = self.smallsize # store the raw image presentation.append((self.small, 'raw')) self.motion = cv.CloneImage(self.small) # location of the thingy moving on the screen is defined by center center = self.process_motion(self.motion) # if an object is found draw the circle on the same location. if center != (-1, -1): cv.Circle(self.motion, center, cv.Round(30), cv.CV_RGB(0, 225, 0), 3, cv.CV_AA, 0) # store the picture presentation.append((self.motion, 'motion')) #### # processing of final image self.eye = cv.CloneImage(self.small) # get a copy (r, color) = self.dejitter(center) cv.Circle(self.eye, self.old_center, cv.Round(r), color, 3, cv.CV_AA, 0) presentation.append((self.eye, 'final')) # combine and show the results combined = self.combine_images(presentation) cv.ShowImage('Motion detection', combined) if self.store: cv.WriteFrame(self.writer, self.combined)
def convert2vid(self, bdjoints): import datetime now = datetime.datetime.now() vid = 'kinect' + repr(now.month).zfill(2) + repr( now.day).zfill(2) + repr(now.hour).zfill(2) + repr( now.minute).zfill(2) + '.avi' video = cv.CreateVideoWriter(vid, cv.CV_FOURCC('L', 'A', 'G', 'S'), fps, (1920, 1080), True) #st = time.clock() #pdb.set_trace() print 'making video .....' for i in fimgs: bitmap = cv.CreateImageHeader((1920, 1080), cv.IPL_DEPTH_8U, 3) cv.SetData(bitmap, i.tostring(), i.dtype.itemsize * 3 * i.shape[1]) cv.WriteFrame(video, bitmap) #print time.clock()-st print 'there r total ' + repr(len(fimgs)) + ' frames' del video cPickle.dump( bdjoints, file( 'bodyjoints' + repr(now.month).zfill(2) + repr(now.day).zfill(2) + repr(now.hour).zfill(2) + repr(now.minute).zfill(2) + '.pkl', 'wb'))
HEIGHT = 480 import sys import os import cv if len(sys.argv) != 4: print "use this te create movie of images\n" print "usage: %s <image folder> <output movie> <showtime>\n" % sys.argv[0] sys.exit(1) image_folder = sys.argv[1] output_movie = sys.argv[2] showtime = int(sys.argv[3]) if not os.access(image_folder, os.X_OK): print "can't acess %s" % image_folder sys.exit(1) writer = cv.CreateVideoWriter(output_movie, cv.CV_FOURCC('M', 'J', 'P', 'G'), FPS, (WIDTH, HEIGHT), True) sized = cv.CreateImage((WIDTH, HEIGHT), cv.IPL_DEPTH_8U, 3) for f in [x for x in os.listdir(image_folder) if not x.startswith('.')]: p = os.path.join(image_folder, f) print "loading", p frame = cv.LoadImage(p) cv.Resize(frame, sized) for i in range(FPS * showtime): print cv.WriteFrame(writer, sized)
python_opencv_modulu.ResetImageROI(goruntu_yakala) toplam.update() if toplam.y + toplam.height >= cerceve_boyutu[1]: toplam.aktif = False sayi -= 1 else: toplam.y = 0 toplam.x = rasgele.randint( 0, cerceve_boyutu[0] - logo_bau.width) if toplam.hiz[1] < 15: toplam.hiz = (0, toplam.hiz[1] + 1) skor += sayi python_opencv_modulu.PutText(goruntu_yakala, "Skorunuz : %d" % skor, (10, cerceve_boyutu[1] - 10), yazi_tipi, python_opencv_modulu.RGB(0, 0, 0)) python_opencv_modulu.ShowImage("Python - Bahçeşehir University Game", cerceve) if yazdir_goruntuyu: python_opencv_modulu.WriteFrame(video_yazdir, goruntu_yakala) python_opencv_modulu.ShowImage("Python - Bahçeşehir University Game", goruntu_yakala) previous = python_opencv_modulu.CloneImage(current) beklenen_anahtar = anahtar.WaitKey(2) if beklenen_anahtar == 27: break gecikme_zamani -= 1 print skor
filename = "../data/output/weighted.avi" # Codec is OS dependant. # FIXME : Find an unified version if "win" in sys.platform: fourcc = cv.CV_FOURCC('C', 'V', 'I', 'D') else: # some kind of Linux/Unix platform fourcc = cv.CV_FOURCC('F', 'M', 'P', '4') fps = 5 frameSize = cv.GetSize(im1) my_video = cv.CreateVideoWriter(filename, fourcc, fps, frameSize, 1) num_inter_im = 10 step = float(1) / 10 for i in range(num_inter_im + 1): print i im3 = cv.CreateImage(cv.GetSize(im1), im1.depth, im1.nChannels) alpha = step * i beta = 1 - alpha gamma = 0 cv.AddWeighted(im1, alpha, im2, beta, gamma, im3) cv.WriteFrame(my_video, im3) # cv.NamedWindow("im3", cv.CV_WINDOW_NORMAL) # cv.ResizeWindow("im3", 640, 480) # cv.MoveWindow("im3", 640, 500) # cv.ShowImage("im3", im3) # cv.WaitKey(delay)
# Next open the file for output outStream = cv.CreateVideoWriter( outputFile, cv.CV_FOURCC('P', 'I', 'M', '1'), fps, (cv.GetCaptureProperty(inStream, cv.CV_CAP_PROP_FRAME_WIDTH), cv.GetCaptureProperty(inStream, cv.CV_CAP_PROP_FRAME_HEIGHT)), 1) # is_color curTime = 0 cvFrame = cv.QueryFrame(inStream) while (cvFrame is not None): frame = np.asarray(cv.GetMat(cvFrame)).astype(np.float64) / 255.0 motionExtractor.AddImage(frame, curTime) if (motionExtractor.RetreiveObjects() is not None and (curTime - motionExtractor.time() < 5.0 / fps)): # Create a new frame showing the objects in red outFrame = frame outFrame[:,:,2] = outFrame[:,:,2]*0.6 + 0.4 * \ motionExtractor.RetreiveObjects().ToBinaryImageMask().astype(np.float64) outFrame *= 255.0 cv.WriteFrame(outStream, cv.GetImage(cv.fromarray(frame.astype(np.uint8())))) cvFrame = cv.QueryFrame(inStream) curTime += 1.0 / fps print 'Processed %f seconds' % curTime