def autoconfig(self): """ Sets the shutterspeed and white balance automatically using the framerate provided in the configuration file """ self._setup_cam(auto=True) with self.rawCapture as stream: for a in range(5): self.cam.capture(stream, format="bgr", use_video_port=True) image = stream.array stream.seek(0) stream.truncate() self.config.cam.shutterspeed = self.cam.exposure_speed self.config.cus.gains = tuple( [round(float(i), 2) for i in self.cam.awb_gains]) self.config.save() lineprint("Shutterspeed set to " + str(self.cam.exposure_speed)) lineprint("White balance gains set to " + str(self.config.cus.gains)) stream.close() self.rawCapture.close() self.cam.close()
def __init__(self, system="auto", framerate=8, vidsize=0.2, internal=False, rotation = 0): """Opens a video stream with user interface to calibrate the camera""" if internal: lineprint("Running calibrate function.. ") self.system = system self.framerate = framerate self.vidsize = vidsize self.rotation = rotation self.cross = False self.stream = True self.exit = False self.roi = False self.fullscreen = False self.tempcol = draw.namedcols("orange") self.col = draw.namedcols("red") cv2.namedWindow("Image", cv2.WND_PROP_FULLSCREEN) self.m = draw.mouse_events() cv2.setMouseCallback('Image', self.m.draw) time.sleep(1) self.drawer()
def _setup_cam(self, auto = False, fps = None): """Sets up the raspberry pi camera based on the configuration""" import picamera import picamera.array self.cam = picamera.PiCamera() self.cam.rotation = self.config.cus.rotation self.cam.exposure_compensation = self.config.cam.compensation if self.config.rec.rectype in ["img","imgseq"]: self.cam.resolution = literal_eval(self.config.img.imgdims) self.cam.framerate = self.config.img.imgfps if self.config.rec.rectype in ["vid","vidseq"]: self.cam.resolution = picamconv(literal_eval(self.config.vid.viddims)) self.cam.framerate = self.config.vid.vidfps if fps != None: self.cam.framerate = fps if self.config.cus.roi is None: self.cam.zoom = (0,0,1,1) self.resize = self.cam.resolution else: self.cam.zoom = literal_eval(self.config.cus.roi) w = int(self.cam.resolution[0]*self.cam.zoom[2]) h = int(self.cam.resolution[1]*self.cam.zoom[3]) if self.config.rec.rectype in ["vid","vidseq"]: self.resize = picamconv((w,h)) else: self.resize = (w,h) self.longexpo = False if self.cam.framerate >= 6 else True self.cam.exposure_mode = "auto" self.cam.awb_mode = "auto" lineprint("Camera warming up..") if auto or self.config.cam.automode: self.cam.shutter_speed = 0 sleep(2) elif self.cam.framerate >= 6: sleep(6) if self.cam.framerate > 1.6 else sleep(10) else: sleep(2) if not auto and self.config.cam.automode == False: self.cam.shutter_speed = self.config.cam.shutterspeed self.cam.exposure_mode = "off" self.cam.awb_mode = "off" self.cam.awb_gains = eval(self.config.cus.gains) sleep(0.1) brightness = self.config.cam.brightness + self.config.cus.brighttune self.cam.brightness = brightness self.cam.contrast = self.config.cam.contrast self.cam.saturation = self.config.cam.saturation self.cam.iso = self.config.cam.iso self.cam.sharpness = self.config.cam.sharpness self.rawCapture = picamera.array.PiRGBArray(self.cam, size=self.cam.resolution)
def draw_stream(self): lineprint("Streaming video..") self.vid = VideoIn(system=self.system, framerate=self.framerate, vidsize=self.vidsize, rotation=self.rotation) self.vid.start() while True: self.img = self.vid.read() if self.cross: draw.draw_cross(self.img, pt2 = self.vid.res) cv2.imshow("Image", self.img) k = cv2.waitKey(1) & 0xFF if k == ord("c"): self.cross = not self.cross if k == ord("f"): self.fullscreen = not self.fullscreen if self.fullscreen: cv2.setWindowProperty("Image",cv2.WND_PROP_FULLSCREEN,cv2.WINDOW_FULLSCREEN) else: cv2.setWindowProperty("Image",cv2.WND_PROP_AUTOSIZE, cv2.WINDOW_NORMAL) cv2.resizeWindow("Image", self.vid.res[0], self.vid.res[1]) if k == ord("d"): self.stream = False break if k == 27: lineprint("User exited..") self.exit = True break self.vid.stop()
def camconfig(self, fps=None, vidsize=0.4): lineprint("Opening stream for interactive configuration..") fps = max(self.config.vid.vidfps,1) if fps==None else int(fps) self._setup_cam(fps=fps) configout = Camconfig(self.cam, auto=self.config.cam.automode, vidsize=vidsize) if len(configout)>0: self.settings(**configout)
def checktimeplan(self): """Checks timeplan and prints description""" valid = crontab.CronSlices.is_valid(self.jobtimeplan) if valid: timedesc = get_description(self.jobtimeplan) lineprint("Your timeplan will run " + timedesc) else: lineprint("Timeplan is not valid..") return valid
def enable_job(self): """Enables/disables a specific job""" if self.jobenable == "True" or self.jobenable == True: self.job.enable(True) lineprint(self.jobname[4:] + " job enabled..") else: self.job.enable(False) lineprint(self.jobname[4:] + " job disabled..") self.cron.write() self.jobsshow = True
def set_gains(self, auto=True): """Find the best gains for the raspberry pi camera""" if self.config.cus.roi == None: zoom = (0, 0, 1, 1) else: zoom = literal_eval(self.config.cus.roi) (rg, bg) = setgains(startgains=checkfrac(self.config.cus.gains), zoom=zoom, auto=auto) self.set_config(gains="(%5.2f, %5.2f)" % (rg, bg), internal="") lineprint("Gains: " + "(R:%5.2f, B:%5.2f)" % (rg, bg) + " stored..")
def draw_frame(self): lineprint("Selecting roi..") self.imgbak = self.img.copy() while True: img = self.imgbak.copy() if self.m.twoPoint is not None: draw.draw_crosshair(img, self.m.pos) if self.m.posDown is not None: cv2.rectangle(img, self.m.posDown, self.m.pos, self.tempcol, 2) if self.m.posUp is not None: cv2.rectangle(img, self.m.pts[-1], self.m.posUp, self.col, 2) cv2.imshow("Image", img) k = cv2.waitKey(1) & 0xFF if k == ord("s"): if self.m.twoPoint is not None: self.m.twoPoint = checkroi(self.m.twoPoint, self.vid.res) self.roi = roi_to_zoom(self.m.twoPoint, self.vid.res) lineprint("roi "+str(self.roi)+" stored..") break else: lineprint("Nothing to store..") if k == ord("e"): self.roi = False lineprint("new roi erased..") if k == ord("z"): if self.m.twoPoint is not None: lineprint("Creating zoomed image..") self.vid2 = VideoIn(system=self.system, vidsize=self.vidsize, crop=self.m.twoPoint, rotation=self.rotation) zimg = self.vid2.img() cv2.namedWindow("Zoomed", cv2.WINDOW_NORMAL) while True: cv2.imshow("Zoomed", zimg) cv2.resizeWindow("Zoomed", self.vid2.roiw, self.vid2.roih) k = cv2.waitKey(1) & 0xFF if k == 27: break k = 255 cv2.destroyWindow("Zoomed") if k == 27: self.stream = True self.m.twoPoint = None break
def set_job(self): """Creates/modifies a specific job""" if len(self.jobfits) > 0: self.job = self.jobfits[0] self.job.command = self.task else: self.job = self.cron.new(command=self.task, comment=self.jobname) if self.jobtimeplan is not None: self.job.setall(self.jobtimeplan) self.cron.write() lineprint(self.jobname[4:] + " job succesfully set..") if self.jobenable is not None: self.enable_job()
def _setup_cam(self): """Sets up the raspberry pi camera based on configuration""" #load picamera module in-function so pirecorder is installable on all OS import picamera import picamera.array self.cam = picamera.PiCamera() self.cam.rotation = self.config.cus.rotation self.cam.exposure_compensation = self.config.cam.compensation if self.config.rec.rectype in ["img", "imgseq"]: self.cam.resolution = literal_eval(self.config.img.imgdims) self.cam.framerate = self.config.img.imgfps if self.config.rec.rectype in ["vid", "vidseq"]: self.cam.resolution = literal_eval(self.config.vid.viddims) self.cam.framerate = self.config.vid.vidfps self.rawCapture = picamera.array.PiRGBArray(self.cam, size=self.cam.resolution) if self.config.cus.roi is None: self.cam.zoom = (0, 0, 1, 1) self.resize = self.cam.resolution else: self.cam.zoom = literal_eval(self.config.cus.roi) w = int(self.cam.resolution[0] * self.cam.zoom[2]) h = int(self.cam.resolution[1] * self.cam.zoom[3]) self.resize = picamconv((w, h)) self.longexpo = False if self.cam.framerate >= 6 else True if self.longexpo: lineprint("Long exposure, warming up camera..") sleep(6) if self.cam.framerate > 1.6 else sleep(10) else: lineprint("Camera warming up..") sleep(2) self.cam.shutter_speed = self.config.cam.shutterspeed self.cam.exposure_mode = "off" self.cam.awb_mode = "off" self.cam.awb_gains = checkfrac(self.config.cus.gains) brightness = self.config.cam.brightness + self.config.cus.brighttune self.cam.brightness = brightness self.cam.contrast = self.config.cam.contrast self.cam.saturation = self.config.cam.saturation self.cam.iso = self.config.cam.iso self.cam.sharpness = self.config.cam.sharpness
def conv_single(self, filein): try: filebase = os.path.basename(filein) fileout = filein if self.outdir == "" else self.outdir + "/" + filebase lineprint("Start converting " + filebase, label="pirecorder") if self.withframe: vid = cv2.VideoCapture(filein) fps, width, height, _ = get_vid_params(vid) if self.fps is None: self.fps = fps vidout = videowriter(fileout, width, height, self.fps, self.resizeval) while True: flag, frame = vid.read() if flag: if self.resizeval != 1: frame = imgresize(frame, self.resizeval) frame_nr = int(vid.get(cv2.CAP_PROP_POS_FRAMES)) draw_text(frame, str(frame_nr), (10, 10), 0.9, col="white", shadow=True) vidout.write(frame) if not flag: break else: if self.resizeval != 1: comm = "' -vf 'scale=iw*" + str(self.resizeval) + ":-2' '" else: comm = "' -vcodec copy '" bashcomm = "ffmpeg" if self.fps is not None: bashcomm = bashcomm + " -r " + str(self.fps) bashcomm = bashcomm + " -i '" + filein + comm + fileout[:-len( self.type)] + ".mp4'" bashcomm = bashcomm + " -y -nostats -loglevel 0" output = subprocess.check_output(['bash', '-c', bashcomm]) lineprint("Finished converting " + filebase, label="pirecorder") except KeyboardInterrupt: raise KeyboardInterruptError()
def rec(): """To run pirecorder from the command line""" parser = argparse.ArgumentParser( prog="record", description="Runs PiRecorder record function") parser.add_argument("-c", "--configfile", default="pirecorder.conf", action="store", help="pirecorder configuration file") args = parser.parse_args() if not isrpi(): lineprint("PiRecorder only works on a raspberry pi. Exiting..") return rec = PiRecorder(args.configfile) rec.settings(internal=True) rec.record()
def set_roi(self): """ Dynamically draw a region of interest Explanation =========== This function will open a video stream of the raspberry pi camera. Enter 'd' to start drawing the region of interest on an image taken from the video stream. When happy with the region selected, press 's' to store the coordinates, or 'esc' key to exit drawing on the image. To exist the video stream enter 'esc' key again. """ C = Calibrate(internal=True, rotation=self.config.cus.rotation) if C.roi: self.set_config(roi=C.roi, internal="") lineprint("Roi stored..") else: lineprint("No roi selected..")
def __init__(self, indir = "", outdir = "", type = ".h264", withframe = False, overwrite = False, delete = False, pools = 4, resizeval = 1, fps = None, imgfps = 25, internal = False, sleeptime = None): if internal: lineprint("Running convert function..", label="pirecorder") self.indir = os.getcwd() if indir == "" else indir assert os.path.exists(self.indir), "in-directory does not exist.." self.outdir = self.indir if outdir == "" else outdir if not os.path.exists(self.outdir): os.makedirs(self.outdir) self.rootdir = os.getcwd() os.chdir(self.indir) self.type = type self.withframe = withframe self.delete = delete self.pools = int(pools) self.resizeval = float(resizeval) self.fps = int(fps) if fps is not None else None self.imgfps = int(imgfps) self.terminated = False while True: files = listfiles(self.indir, self.type, keepdir = False) old = listfiles(self.indir, self.type, keepext = False) new = listfiles(self.outdir, ".mp4", keepext = False) self.todo = files if not overwrite: self.todo = [files[i] for i,file in enumerate(old) if file not in new] if self.type in [".jpg",".jpeg",".png"] and len(self.todo)>0: if len([f for f in new if commonpref(self.todo) in f])>0 and not overwrite: self.todo = [] self.convertpool() msg = "No files to convert.." if sleeptime == None: if not self.terminated: lineprint(msg, label="pirecorder") return else: try: lineprint(msg+" rechecking in "+str(sleeptime)+"s..", label="pirecorder") time.sleep(sleeptime) except KeyboardInterrupt: lineprint("Terminating checking for files..", label="pirecorder") return
def show_jobs(self): """Displays a table of all scheduled jobs""" if len(self.cron) > 0: lineprint("Current job schedule:") for job in self.cron: lenjob = max(8, len(job.comment[4:])) lenplan = max(8, len(str(job)[:str(job).find(" /")])) header = "Job" + " " * (lenjob - 1) + "Timeplan" + " " * ( lenplan - 7) + "Next recording" print(header) print("-" * len(header)) self.jobs = self.get_jobs() for job in self.jobs: sch = job.schedule(date_from=datetime.datetime.now()) jobname = job.comment[4:] + " " * (lenjob - (len(job.comment[4:]) - 2)) plan = str(job)[:str(job).find(" /") - 2] plan = plan[2:] if plan[0] == "#" else plan plan = plan + " " * (lenplan - (len(plan) - 1)) next = str(sch.get_next()) if job.is_enabled() else "disabled" print(jobname + plan + next) else: lineprint("Currently no jobs scheduled..")
def __init__(self, jobname=None, timeplan=None, enable=None, showjobs=False, delete=None, test=False, internal=False, configfile="pirecorder.conf", logfolder="/home/pi/pirecorder/"): if internal: lineprint("Running schedule function.. ") self.cron = crontab.CronTab(user=getpass.getuser()) if jobname is not None: self.jobname = "REC_" + jobname pexec = sys.executable + " -c " pcomm1 = """'import pirecorder; """ pcomm2 = """R=pirecorder.PiRecorder("%s"); R.record()'""" % configfile log1 = " >> " + logfolder + "$(date +%y%m%d)_" log2 = str(self.jobname[4:]) + ".log 2>&1" self.task = pexec + pcomm1 + pcomm2 + log1 + log2 else: self.jobname = None self.jobtimeplan = timeplan self.jobenable = enable self.jobsshow = showjobs self.jobsclear = delete if self.jobsclear not in [None, "all"] and self.jobname == None: self.jobname = "REC_" + self.jobsclear self.jobs = self.get_jobs() self.jobfits = self.get_jobs(name=self.jobname) if self.jobsclear is not None: self.clear_jobs() elif not self.jobsshow: if self.jobtimeplan is None and self.jobname is None and not test: self.jobsshow = True elif self.jobtimeplan is None and self.jobname is not None and not test and len( self.jobfits) == 0: lineprint("No timeplan provided..") elif self.jobtimeplan is not None and self.jobname is None and not test: lineprint("No jobname provided..") elif test and self.jobtimeplan is not None: self.checktimeplan() else: if enable is None: self.checktimeplan() self.set_job() if self.jobsshow: self.show_jobs()
def stream(self, fps=None): """Shows an interactive video stream""" lineprint("Opening stream for cam positioning and roi extraction..") vidstream = Stream(internal=True, rotation=self.config.cus.rotation, maxres=self.config.rec.maxres) if vidstream.roi: self.settings(roi=vidstream.roi, internal="") lineprint("Roi stored..") else: lineprint("No roi selected..")
def clear_jobs(self): """Clears a specific or all jobs currently scheduled""" if self.jobsclear == None: pass elif self.jobsclear == "all": for job in self.jobs: if job.comment[:3] == "REC": self.cron.remove(job) lineprint("All scheduled jobs removed..") else: if len(self.jobfits) > 0: self.cron.remove(self.jobfits[0]) lineprint(self.jobname[4:] + " job removed..") else: lineprint("No fitting job found to remove..") self.cron.write() self.jobsshow = True
def __init__(self, system = "auto", framerate = 8, vidsize = 0.2, rotation = 0, internal = False, maxres = None, imgoverlay = None): """ Opens a video stream with user interface to help position and adjust the camera parameters ----------- system : str, default = "auto" If the system should be automatically determined. Should detect if the computer is a raspberry pi or not. If this somehow fails, set to "rpi" manually. framerate : int, default = 8 The framerate of the displayed video stream. Lower framerates take longer to start up. When using an image overlay, maximum possible framerate is 5, to avoid getting shutter effects vidsize : float, default = 0.2 The relative size of the video window to the maximum resolution of the raspberry pi camera type. rotation : int, default = 180 If the camera should be rotated or not. 0 and 180 are valid values. maxres : str or tuple, default = "v2" The maximum potential resolution of the camera used. Either provide a tuple of the max resolution, or use "v1.5", "v2" (default), or "hq" to get the maximum resolution associated with the official cameras directly. imgoverlay : str, default = None The path to an image that will be overlaid on the video stream. This can be helpful for accurate positioning of the camera in line with previous recordings or setups. interface ----------- This interactive module stores mouse position and clicks and responds to the following keypresses: f-key : display the stream fullscreen/display the stream in a window c-key : display/hide a diagonal cross across the screen s-key : save the coordinates of the rectangular area when drawn e-key : erase the rectangular area when drawn z-key : show a zoomed-in section of the video inside the rectangular area in maximum resolution n-key : refresh the zoom-in image o-key : if the potential overlay image should be shown or not [- and ]-keys : decrease or increase the relative opacity of the potential overlay image with 5% esc-key : exit the the zoom window; exit the calibrate function """ self.internal = internal if self.internal: lineprint("Running stream function.. ") self.system = system self.framerate = framerate self.vidsize = vidsize self.rotation = rotation self.maxres = maxres if imgoverlay == None: self.overlay = False self.waitms = 1 else: if os.path.isfile(imgoverlay): self.overlay = True self.overlayimg = cv2.imread(imgoverlay) self.alpha = 0.5 self.waitms = 200 self.framerate = min(self.framerate, 5) else: print("Image file could not be loaded..") self.cross = False self.stream = True self.exit = False self.roi = False self.fullscreen = False self.tempcol = draw.namedcols("orange") self.col = draw.namedcols("red") cv2.namedWindow("Image", cv2.WND_PROP_FULLSCREEN) self.m = draw.mouse_events() cv2.setMouseCallback('Image', self.m.draw) time.sleep(1) self.drawer()
def record(self): """Runs the Recorder instance""" self._setup_cam() self._namefile() if self.config.rec.rectype == "img": self.filename = self.filename + strftime("%H%M%S") + self.filetype self.cam.capture(self.filename, format="jpeg", resize=self.resize, quality=self.config.img.imgquality) lineprint("Captured " + self.filename) elif self.config.rec.rectype == "imgseq": timepoint = datetime.now() for i, img in enumerate( self.cam.capture_continuous( self.filename, format="jpeg", resize=self.resize, quality=self.config.img.imgquality)): if i < self.config.img.imgnr - 1: timepassed = (datetime.now() - timepoint).total_seconds() delay = max(0, self.config.img.imgwait - timepassed) lineprint("Captured " + img + ", sleeping " + str(round(delay, 2)) + "s..") sleep(delay) timepoint = datetime.now() else: lineprint("Captured " + img) break elif self.config.rec.rectype in ["vid", "vidseq"]: # Temporary fix for flicker at start of (first) video.. self.cam.start_recording(BytesIO(), format="h264", resize=self.resize) self.cam.wait_recording(2) self.cam.stop_recording() for session in ["_S%02d" % i for i in range(1, 999)]: session = "" if self.config.rec.rectype == "vid" else session filename = self.filename + strftime( "%H%M%S") + session + self.filetype self.cam.start_recording(filename, resize=self.resize, quality=self.config.vid.vidquality) lineprint("Start recording " + filename) self.cam.wait_recording(self.config.vid.vidduration + self.config.vid.viddelay) self.cam.stop_recording() lineprint("Finished recording " + filename) if self.config.rec.rectype == "vid": break else: if input("\nAny key for new session, e to exit: ") == "e": break self.cam.close()
def Camconfig(cam=None, auto=None, iso=200, framerate=20, res=(1640, 1232), vidsize=0.4): """ Opens a video stream to configure a wide array of camera parameters Note: A screen resolution of at least 800x600 is strongly recommended """ if not isrpi(): lineprint("PiRecorder only works on a raspberry pi. Exiting..") return import picamera import picamera.array def nothing(x): pass if cam == None: cam = picamera.PiCamera() cam.resolution = res cam.iso = iso cam.framerate = framerate time.sleep(2) if cam == None or (auto == None or auto == True): cam.exposure_mode = "auto" set_auto = 1 else: set_auto = 0 res = (cam.resolution[0] * vidsize, cam.resolution[1] * vidsize) res = (int(res[0] * cam.zoom[2]), int(res[1] * cam.zoom[3])) if (res[0] * res[1]) >= (1640 * 1232): res = maxrect(dims, maxdims=(1640, 1232), decimals=0) cam.resolution = picamconv(res) cv2.namedWindow("Stream", cv2.WND_PROP_FULLSCREEN) cv2.namedWindow("Config", cv2.WINDOW_NORMAL) cv2.setWindowProperty("Stream", cv2.WND_PROP_AUTOSIZE, cv2.WINDOW_NORMAL) cv2.resizeWindow("Stream", cam.resolution[0], cam.resolution[1]) config = [] isos = [100, 200, 320, 400, 500, 640, 800] set_rot = cam.rotation * 180 set_fps = int(cam.framerate) set_iso = [i for i, j in enumerate(isos) if j == cam.iso][0] set_comp = cam.exposure_compensation + 25 set_shut = cam.shutter_speed set_red = int(float(cam.awb_gains[0]) * 10) set_blue = int(float(cam.awb_gains[1]) * 10) set_bri = cam.brightness set_con = cam.contrast + 100 set_sat = cam.saturation + 100 set_shar = cam.sharpness + 100 cv2.createTrackbar("rotation (0deg/180deg)", "Config", set_rot, 1, nothing) cv2.createTrackbar("framerate", "Config", set_fps, 40, nothing) cv2.createTrackbar("automatic (off/on)", "Config", set_auto, 1, nothing) cv2.createTrackbar("iso", "Config", set_iso, 6, nothing) cv2.createTrackbar("compensation", "Config", set_comp, 50, nothing) cv2.createTrackbar("shutterspeed (ms)", "Config", set_shut, 99999, nothing) cv2.createTrackbar("red gain", "Config", set_red, 80, nothing) cv2.createTrackbar("blue gain", "Config", set_blue, 80, nothing) cv2.createTrackbar("brightness", "Config", set_bri, 100, nothing) cv2.createTrackbar("contrast", "Config", set_con, 200, nothing) cv2.createTrackbar("saturation", "Config", set_sat, 200, nothing) cv2.createTrackbar("sharpness", "Config", set_shar, 200, nothing) rawCapture = picamera.array.PiRGBArray(cam, size=cam.resolution) lineprint("Streaming interactive video..") with rawCapture as stream: while True: cam.capture(stream, format="bgr", use_video_port=True) image = stream.array rot = cv2.getTrackbarPos("rotation (0deg/180deg)", "Config") fps = cv2.getTrackbarPos("framerate", "Config") auto = cv2.getTrackbarPos("automatic (off/on)", "Config") iso = cv2.getTrackbarPos("iso", "Config") comp = cv2.getTrackbarPos("compensation", "Config") shut = cv2.getTrackbarPos("shutterspeed (ms)", "Config") red = cv2.getTrackbarPos("red gain", "Config") blue = cv2.getTrackbarPos("blue gain", "Config") bri = cv2.getTrackbarPos("brightness", "Config") con = cv2.getTrackbarPos("contrast", "Config") sat = cv2.getTrackbarPos("saturation", "Config") shar = cv2.getTrackbarPos("sharpness", "Config") cam.rotation = [0, 180][rot] cam.framerate = max(fps, 1) cam.exposure_mode = ["off", "auto"][auto] cam.iso = isos[iso] cam.exposure_compensation = comp - 25 cam.awb_mode = cam.exposure_mode if cam.exposure_mode == "off": cam.shutter_speed = shut maxshut = int(float(1 / cam.framerate) * 1000000) if shut > maxshut: cv2.setTrackbarPos("shutterspeed (ms)", "Config", maxshut) cam.awb_gains = (red / 10, blue / 10) if cam.exposure_mode == "auto": cam.shutter_speed = 0 shut = cam.exposure_speed red, blue = [int(float(i) * 10) for i in cam.awb_gains] cv2.setTrackbarPos("shutterspeed (ms)", "Config", shut) cv2.setTrackbarPos("red gain", "Config", red) cv2.setTrackbarPos("blue gain", "Config", blue) cam.brightness = bri cam.contrast = con - 100 cam.saturation = sat - 100 cam.sharpness = shar - 100 cv2.imshow("Stream", image) stream.truncate(0) k = cv2.waitKey(10) & 0xFF if k == ord("s"): if cam.shutter_speed == 0: shutterspeed = cam.exposure_speed else: shutterspeed = cam.shutter_speed gains = tuple([round(float(i), 2) for i in cam.awb_gains]) config = { "automode": [False, True][auto], "vidfps": cam.framerate, "rotation": cam.rotation, "gains": gains, "brightness": cam.brightness, "contrast": cam.contrast, "saturation": cam.saturation, "iso": cam.iso, "sharpness": cam.sharpness, "compensation": cam.exposure_compensation, "shutterspeed": shutterspeed } break if k == 27: lineprint("User exited..") break rawCapture.close() cam.close() cv2.destroyAllWindows() cv2.waitKey(1) return config
def record(self): """ Starts a recording as configured and returns either one or multiple .h264 or .jpg files that are named automatically according to the label, the host name, date, time and potentially session number or count nr. Example output files: rectype = "img" : test_180312_pi13_101300.jpg rectype = "vid" : test_180312_pi13_102352.h264 rectype = "imgseq" : test_180312_pi13_img00231_101750.jpg rectype = "vidseq" : test_180312_pi13_101810_S01.h264 """ self._setup_cam() self._namefile() if self.config.rec.rectype == "img": self.filename = self.filename + strftime("%H%M%S") + self.filetype self.cam.capture(self.filename, format="jpeg", resize = self.resize, quality = self.config.img.imgquality) lineprint("Captured "+self.filename) elif self.config.rec.rectype == "imgseq": timepoint = datetime.now() for i, img in enumerate(self.cam.capture_continuous(self.filename, format="jpeg", resize = self.resize, quality = self.config.img.imgquality)): if i < self.config.img.imgnr-1: timepassed = (datetime.now() - timepoint).total_seconds() delay = max(0, self.config.img.imgwait - timepassed) lineprint("Captured "+img+", sleeping "+str(round(delay,2))+"s..") sleep(delay) timepoint = datetime.now() else: lineprint("Captured "+img) break elif self.config.rec.rectype in ["vid","vidseq"]: # Temporary fix for flicker at start of (first) video self.cam.start_recording(BytesIO(), format = "h264", resize = self.resize, level = "4.2") self.cam.wait_recording(2) self.cam.stop_recording() for session in ["_S%02d" % i for i in range(1,999)]: session = "" if self.config.rec.rectype == "vid" else session filename = self.filename+strftime("%H%M%S")+session+self.filetype self.cam.start_recording(filename, resize = self.resize, quality = self.config.vid.vidquality, level = "4.2") lineprint("Start recording "+filename) self.cam.wait_recording(self.config.vid.vidduration+self.config.vid.viddelay) self.cam.stop_recording() lineprint("Finished recording "+filename) if self.config.rec.rectype == "vid": break else: msg = "\nPress Enter for new session, or e and Enter to exit: " if input(msg) == "e": break self.cam.close()
def __init__(self, indir="", outdir="", type=".h264", withframe=False, overwrite=False, delete=False, pools=4, resizeval=1, fps=None, imgfps=25, internal=False, sleeptime=None, interrupt=True): if internal: lineprint("Running convert function..") global interrupted interrupted = False if interrupt: def keythread(): global interrupted input() interrupted = True Thread(target=keythread).start() self.indir = os.getcwd() if indir == "" else indir assert os.path.exists(self.indir), "in-directory does not exist.." self.outdir = self.indir if outdir == "" else outdir assert os.path.exists(self.outdir), "out-directory does not exist.." self.rootdir = os.getcwd() os.chdir(self.indir) self.type = type self.withframe = withframe self.delete = delete self.pools = int(pools) self.resizeval = float(resizeval) self.fps = int(fps) if fps is not None else None self.imgfps = int(imgfps) while not interrupted: files = listfiles(self.indir, self.type, keepdir=False) old = listfiles(self.indir, self.type, keepext=False) new = listfiles(self.outdir, ".mp4", keepext=False) self.todo = files if not overwrite: self.todo = [ files[i] for i, file in enumerate(old) if file not in new ] if self.type in [".jpg", ".jpeg", ".png"] and len(self.todo) > 0: if len([f for f in new if commonpref(self.todo) in f]) > 0: self.todo = [] self.convertpool() msg = "No files to convert.." if sleeptime == None: lineprint(msg) break else: lineprint(msg + " rechecking in " + str(sleeptime) + "s..") time.sleep(sleeptime)
def __init__(self, configfile="pirecorder.conf", logging=True): if not isrpi(): lineprint("PiRecorder only works on a raspberry pi. Exiting..") return self.system = "auto" self.host = gethostname() self.home = homedir() self.setupdir = self.home + "pirecorder" self.logfolder = self.setupdir + "/logs/" if not os.path.exists(self.logfolder): os.makedirs(self.setupdir) os.makedirs(self.logfolder) lineprint("Setup folder created (" + self.setupdir + ")..") if not os.path.exists(self.logfolder): lineprint("Setup folder exists but was not set up properly..") if logging: self.log = Logger(self.logfolder + "/pirecorder.log") self.log.start() print("") lineprint("pirecorder " + __version__ + " started!", date=True) lineprint("=" * 47, False) self.brightfile = self.setupdir + "/cusbright.yml" self.configfilerel = configfile self.configfile = self.setupdir + "/" + configfile self.config = LocalConfig(self.configfile, compact_form=True) if not os.path.isfile(self.configfile): lineprint("Config file " + configfile + " not found, new file created..") for section in ["rec", "cam", "cus", "img", "vid"]: if section not in list(self.config): self.config.add_section(section) self.settings(recdir="pirecorder/recordings", subdirs=False, label="test", rectype="img", rotation=0, brighttune=0, roi=None, gains=(1.0, 2.5), brightness=45, contrast=10, saturation=0, iso=200, sharpness=0, compensation=0, shutterspeed=8000, imgdims=(2592, 1944), maxres=None, viddims=(1640, 1232), imgfps=1, vidfps=24, imgwait=5.0, imgnr=12, imgtime=60, imgquality=50, vidduration=10, viddelay=10, vidquality=11, automode=True, internal="", maxviddur=3600, maxvidsize=0) lineprint("Config settings stored..") else: lineprint("Config file " + configfile + " loaded..") lineprint("Recording " + self.config.rec.rectype + " in " +\ self.home + self.config.rec.recdir) self._imgparams() self._shuttertofps() if self.config.rec.rectype == "imgseq": if self.config.cam.shutterspeed / 1000000. >= ( self.config.img.imgwait / 5): lineprint("imgwait is not enough for provided shutterspeed" + \ ", will be overwritten..") if self.config.rec.recdir == "NAS": if not os.path.ismount(self.config.rec.recdir): self.recdir = self.home lineprint("Recdir not mounted, storing in home directory..") self.recdir = self.home + self.config.rec.recdir if not os.path.exists(self.recdir): os.makedirs(self.recdir) os.chdir(self.recdir)
def draw_stream(self): lineprint("Streaming video..") self.vid = VideoIn(system=self.system, framerate=self.framerate, vidsize=self.vidsize, rotation=self.rotation, maxres=self.maxres) self.vid.start() if self.overlay: h, w, _ = self.vid.read().shape self.overlayimg = imgresize(self.overlayimg, resize=1, dims=(w,h)) while True: self.img = self.vid.read() if self.overlay: overlay = self.img.copy() overlay[0:h,0:w] = self.overlayimg cv2.addWeighted(overlay, self.alpha, self.img, 1-self.alpha, 0, self.img) if self.cross: draw.draw_cross(self.img, pt2 = self.vid.res) if self.m.twoPoint is not None: draw.draw_crosshair(self.img, self.m.pos) if self.m.posDown is not None: cv2.rectangle(self.img, self.m.posDown, self.m.pos, self.tempcol, 2) if self.m.posUp is not None: cv2.rectangle(self.img, self.m.pts[-1], self.m.posUp, self.col, 2) cv2.imshow("Image", self.img) k = cv2.waitKey(self.waitms) & 0xFF if k == ord("o"): self.overlay = not self.overlay if k == ord("c"): self.cross = not self.cross if k == ord("f"): self.fullscreen = not self.fullscreen if self.fullscreen: cv2.setWindowProperty("Image", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN) else: cv2.setWindowProperty("Image", cv2.WND_PROP_AUTOSIZE, cv2.WINDOW_NORMAL) cv2.resizeWindow("Image", self.vid.res[0], self.vid.res[1]) if k == ord("s"): if self.m.twoPoint is not None: self.m.twoPoint = checkroi(self.m.twoPoint, self.vid.res) self.roi = roi_to_zoom(self.m.twoPoint, self.vid.res) if self.internal is True: lineprint("roi "+str(self.roi)+" stored..") else: lineprint("roi: "+str(self.roi)) else: lineprint("Nothing selected..") if k == ord("e"): self.m.posUp = None self.roi = False lineprint("roi data erased..") if k == ord("z"): if self.m.twoPoint is not None: lineprint("Creating zoomed image..") self.stream = False break if self.overlay and k == ord("["): self.alpha = max(self.alpha-0.05, 0) if self.overlay and k == ord("]"): self.alpha = min(self.alpha+0.05, 1) if k == 27: lineprint("User exited..") self.exit = True break self.vid.stop() time.sleep(1)
def record(self): """ Starts a recording as configured and returns either one or multiple .h264 or .jpg files that are named automatically according to the label, the host name, date, time and potentially session number or count nr. Example output files: rectype = "img" : test_180312_pi13_101300.jpg rectype = "vid" : test_180312_pi13_102352.h264 rectype = "imgseq" : test_180312_pi13_img00231_101750.jpg rectype = "vidseq" : test_180312_pi13_101810_S01.h264 """ self._setup_cam() self._namefile() if self.config.rec.rectype == "img": self.filename = self.filename + strftime("%H%M%S") + self.filetype self.cam.capture(self.filename, format="jpeg", resize=self.resize, quality=self.config.img.imgquality) lineprint("Captured " + self.filename) elif self.config.rec.rectype == "imgseq": starttime = datetime.now() timepoint = starttime for i, img in enumerate( self.cam.capture_continuous( self.filename, format="jpeg", resize=self.resize, quality=self.config.img.imgquality)): tottimepassed = (datetime.now() - starttime).total_seconds() if i < self.config.img.imgnr - 1 and tottimepassed < self.config.img.imgtime: timepassed = (datetime.now() - timepoint).total_seconds() delay = max(0, self.config.img.imgwait - timepassed) lineprint("Captured " + img + ", sleeping " + str(round(delay, 2)) + "s..") sleep(delay) timepoint = datetime.now() else: lineprint("Captured " + img) break elif self.config.rec.rectype in ["vid", "vidseq"]: # Temporary fix for flicker at start of (first) video self.cam.start_recording(BytesIO(), format="h264", resize=self.resize, level="4.2") self.cam.wait_recording(2) self.cam.stop_recording() for session in ["_S%02d" % i for i in range(1, 999)]: session = "" if self.config.rec.rectype == "vid" else session filename = self.filename + strftime("%H%M%S") + session timeremaining = self.config.vid.vidduration + self.config.vid.viddelay counter = 0 while timeremaining > 0: counter += 1 waittime = timeremaining if self.config.vid.maxviddur > 0: waittime = min(timeremaining, self.config.vid.maxviddur) if waittime == timeremaining and self.config.vid.maxvidsize == 0: nr = "" else: nr = "_v" + str(counter).zfill(2) finalname = filename + nr + self.filetype video = VidOutput(finalname) self.cam.start_recording( video, resize=self.resize, quality=self.config.vid.vidquality, level="4.2", format=self.filetype[1:]) lineprint("Start recording " + filename) rectime = 0 while video.size < self.maxvidsize * 1000000 and rectime < waittime: rectime += 0.1 self.cam.wait_recording(0.1) timeremaining -= rectime self.cam.stop_recording() vidinfo = " (" + str(round(rectime)) + "s; " + str( round(video.size / 1000000, 2)) + "MB)" lineprint("Finished recording " + finalname + vidinfo) if self.config.rec.rectype == "vid": break else: msg = "\nPress Enter for new session, or e and Enter to exit: " if input(msg) == "e": break self.cam.close()
def settings(self, **kwargs): """ Configure the camera and recording settings Parameters --------------- recdir : str, default = "pirecorder/recordings" The directory where media will be stored. Default is "recordings". If different, a folder with name corresponding to location will be created inside the home directory. If no name is provided (""), the files are stored in the home directory. If "NAS" is provided it will additionally check if the folder links to a mounted drive. subdirs : bool, default = False If files of individual recordings should be stored in subdirectories or not, to keep all files of a single recording session together. label : str, default = "test" Label that will be associated with the specific recording and stored in the filenames. rectype : ["img", "imgseq", "vid", "vidseq"], default = "img" Recording type, either a single image or video or a sequence of images or videos. automode : bool, default = True If the shutterspeed and white balance should be set automatically and dynamically for each recording. maxres : str or tuple, default = "v2" The maximum potential resolution of the camera used. Either provide a tuple of the max resolution, or use "v1.5", "v2" (default), or "hq" to get the maximum resolution associated with the official cameras directly. rotation : int, default = 0 Custom rotation specific to the Raspberry Pi, should be either 0 or 180. brighttune : int, default = 0 A rpi-specific brightness compensation factor to standardize light levels across multiple rpi"s, an integer between -10 and 10. roi : tuple, default = None Region of interest to be used for recording. Consists of coordinates of top left and bottom right coordinate of a rectangular area encompassing the region of interest. Can be set with the set_roi() method. gains : tuple, default = (1.0, 2.5) Sets the blue and red gains to acquire the desired white balance. Expects a tuple of floating values (e.g. "(1.5, 1.85)"). Can be automatically set with the autoconfig() function and interactively with the camconfig() function using a live video stream. brightness : int, default = 45 Sets the brightness level of the camera. Expects an integer value between 0 and 100. Higher values result in brighter images. contrast : int, default = 20 Sets the contrast for the recording. Expects an integer value between 0 and 100. Higher values result in images with higher contrast. saturation : int, default 0 Sets the saturation level for the recording. Expects an integer value between -100 and 100. iso : int, default = 200 Sets the camera ISO value. Should be one of the following values: [100, 200, 320, 400, 500, 640, 800]. Higher values result in brighter images but with higher gain. sharpness : int, default = 50 Sets the sharpness of the camera. Expects an integer value between -100 and 100. Higher values result in sharper images. compensation : int, default = 0 Adjusts the camera’s exposure compensation level before recording. Expects a value between -25 and 25, with each increment representing 1/6th of a stop and thereby a brighter image. shutterspeed : int, detault = 10000 Sets the shutter speed of the camera in microseconds, i.e. a value of 10000 would indicate a shutterspeed of 1/100th of a second. A longer shutterspeed will result in a brighter image but more motion blur. Important to consider is that the framerate of the camera will be adjusted based on the shutterspeed. At low shutterspeeds (i.e. above ~ 0.2s) the required waiting time between images increases considerably due to the raspberry pi hardware. To control for this, automatically a standard `imgwait` time should be chosen that is at least 6x the shutterspeed. For example, for a shutterspeed of 300000 imgwait should be > 1.8s. imgdims : tuple, default = (2592, 1944) The resolution of the images to be taken in pixels. The default is the max resolution for the v1.5 model, the v2 model has a max resolution of 3280 x 2464 pixels, and the hq camera 4056 x 3040 pixels. viddims : tuple, default = (1640, 1232) The resolution of the videos to be taken in pixels. The default is the max resolution that does not return an error for this mode. imgfps : int, default = 1 The framerate for recording images. Will be set automatically based on the imgwait setting so should not be set by user. vidfps : int, default = 24 The framerate for recording video. imgwait : float, default = 5.0 The delay between subsequent images in seconds. When a delay is provided that is less than ~x5 the shutterspeed, the camera processing time will take more time than the provided imgwait parameter and so images are taken immideately one after the other. To take a sequence of images at the exact right delay interval the imgwait parameter should be at least 5x the shutterspeed (e.g. shutterspeed of 400ms needs imgwait of 2s). imgnr : int, default = 12 The number of images that should be taken. When this number is reached, the recorder will automatically terminate. imgtime : integer, default = 60 The time in seconds during which images should be taken. The minimum of a) imgnr and b) nr of images based on imgwait and imgtime will be used. imgquality : int, default = 50 Specifies the quality that the jpeg encoder should attempt to maintain. Use values between 1 and 100, where higher values are higher quality. vidduration : int, default = 10 Duration of video recording in seconds. viddelay : int, default = 0 Extra recording time in seconds that will be added to vidduration. Its use is to add a standard amount of time to the video that can be easily cropped or skipped, such as for tracking, but still provides useful information, such as behaviour during acclimation. vidquality : int, default = 11 Specifies the quality that the h264 encoder should attempt to maintain. Use values between 10 and 40, where 10 is extremely high quality, and 40 is extremely low. maxviddur : int, default = 3600 The maximum duration in seconds for single videos, beyond which videos will be automatically split. A value of 0 indicates there is no maximum file duration. maxvidsize : int, default = 0 The maximum file size in Megabytes for single videos, beyond which videos will be automatically split. A value of 0 indicates there is no maximum file size. """ if "recdir" in kwargs: self.config.rec.recdir = kwargs["recdir"] if "subdirs" in kwargs: self.config.rec.subdirs = kwargs["subdirs"] if "label" in kwargs: self.config.rec.label = kwargs["label"] if "rectype" in kwargs: self.config.rec.rectype = kwargs["rectype"] if "maxres" in kwargs: self.config.rec.maxres = kwargs["maxres"] if isinstance(self.config.rec.maxres, tuple): self.config.img.imgdims = self.config.rec.maxres elif self.config.rec.maxres == "v2": self.config.img.imgdims = (3264, 2464) elif self.config.rec.maxres == "hq": self.config.img.imgdims = (4056, 3040) if "rotation" in kwargs: self.config.cus.rotation = kwargs["rotation"] if "brighttune" in kwargs: self.config.cus.brighttune = kwargs["brighttune"] if "roi" in kwargs: self.config.cus.roi = kwargs["roi"] if "gains" in kwargs: self.config.cus.gains = kwargs["gains"] if "automode" in kwargs: self.config.cam.automode = kwargs["automode"] if "brightness" in kwargs: self.config.cam.brightness = kwargs["brightness"] if "contrast" in kwargs: self.config.cam.contrast = kwargs["contrast"] if "saturation" in kwargs: self.config.cam.saturation = kwargs["saturation"] if "iso" in kwargs: self.config.cam.iso = kwargs["iso"] if "sharpness" in kwargs: self.config.cam.sharpness = kwargs["sharpness"] if "compensation" in kwargs: self.config.cam.compensation = kwargs["compensation"] if "shutterspeed" in kwargs: self.config.cam.shutterspeed = kwargs["shutterspeed"] if "imgdims" in kwargs: self.config.img.imgdims = kwargs["imgdims"] if "viddims" in kwargs: self.config.vid.viddims = kwargs["viddims"] if "imgfps" in kwargs: self.config.img.imgfps = kwargs["imgfps"] if "vidfps" in kwargs: self.config.vid.vidfps = kwargs["vidfps"] if "imgwait" in kwargs: self.config.img.imgwait = kwargs["imgwait"] if "imgnr" in kwargs: self.config.img.imgnr = kwargs["imgnr"] if "imgtime" in kwargs: self.config.img.imgtime = kwargs["imgtime"] if "imgquality" in kwargs: self.config.img.imgquality = kwargs["imgquality"] if "vidduration" in kwargs: self.config.vid.vidduration = kwargs["vidduration"] if "viddelay" in kwargs: self.config.vid.viddelay = kwargs["viddelay"] if "maxviddur" in kwargs: self.config.vid.maxviddur = kwargs["maxviddur"] if "maxvidsize" in kwargs: self.config.vid.maxvidsize = kwargs["maxvidsize"] brightchange = False if os.path.exists(self.brightfile): with open(self.brightfile) as f: brighttune = yaml.load(f, Loader=yaml.FullLoader) if brighttune != self.config.cus.brighttune: if "internal" not in kwargs: lineprint("cusbright.yml file found and loaded..") self.config.cus.brighttune = brighttune brightchange = True if len(kwargs) > 0 or brightchange: self._imgparams() self._shuttertofps() if self.config.rec.rectype == "imgseq": if self.config.cam.shutterspeed / 1000000. >= ( self.config.img.imgwait / 5): lineprint("imgwait is not enough for provided shutterspeed" + \ ", will be overwritten..") self.config.save() if "internal" not in kwargs: lineprint("Config settings stored and loaded..")
def set_config(self, **kwargs): """ Dynamically sets the configuration file """ if "recdir" in kwargs: self.config.rec.recdir = kwargs["recdir"] if "subdirs" in kwargs: self.config.rec.subdirs = kwargs["subdirs"] if "label" in kwargs: self.config.rec.label = kwargs["label"] if "rectype" in kwargs: self.config.rec.rectype = kwargs["rectype"] if "rotation" in kwargs: self.config.cus.rotation = kwargs["rotation"] if "brighttune" in kwargs: self.config.cus.brighttune = kwargs["brighttune"] if "roi" in kwargs: self.config.cus.roi = kwargs["roi"] if "gains" in kwargs: self.config.cus.gains = kwargs["gains"] if "brightness" in kwargs: self.config.cam.brightness = kwargs["brightness"] if "contrast" in kwargs: self.config.cam.contrast = kwargs["contrast"] if "saturation" in kwargs: self.config.cam.saturation = kwargs["saturation"] if "iso" in kwargs: self.config.cam.iso = kwargs["iso"] if "sharpness" in kwargs: self.config.cam.sharpness = kwargs["sharpness"] if "compensation" in kwargs: self.config.cam.compensation = kwargs["compensation"] if "shutterspeed" in kwargs: self.config.cam.shutterspeed = kwargs["shutterspeed"] if "imgdims" in kwargs: self.config.img.imgdims = kwargs["imgdims"] if "viddims" in kwargs: self.config.vid.viddims = kwargs["viddims"] if "imgfps" in kwargs: self.config.img.imgfps = kwargs["imgfps"] if "vidfps" in kwargs: self.config.vid.vidfps = kwargs["vidfps"] if "imgwait" in kwargs: self.config.img.imgwait = kwargs["imgwait"] if "imgnr" in kwargs: self.config.img.imgnr = kwargs["imgnr"] if "imgtime" in kwargs: self.config.img.imgtime = kwargs["imgtime"] if "imgquality" in kwargs: self.config.img.imgquality = kwargs["imgquality"] if "vidduration" in kwargs: self.config.vid.vidduration = kwargs["vidduration"] if "viddelay" in kwargs: self.config.vid.viddelay = kwargs["viddelay"] if "vidquality" in kwargs: self.config.vid.vidquality = kwargs["vidquality"] brightchange = False if os.path.exists(self.brightfile): with open(self.brightfile) as f: brighttune = yaml.load(f, Loader=yaml.FullLoader) if brighttune != self.config.cus.brighttune: self.config.cus.brighttune = brighttune brightchange = True if len(kwargs) > 0 or brightchange: self._imgparams() self._shuttertofps() self.config.save() if "internal" not in kwargs: lineprint("Config settings stored and loaded..")
def convertpool(self): if len(self.todo) > 0: if self.type in [".h264", ".mp4", ".avi"]: pool = Pool(min(self.pools, len(self.todo))) try: pool.map(self.conv_single, self.todo) pool.close() lineprint("Done converting all videofiles!", label="pirecorder") except KeyboardInterrupt: lineprint("User terminated converting pool..", label="pirecorder") self.terminated = True pool.terminate() return except Exception as e: excep = "Got exception: %r, terminating pool" % (e, ) lineprint(excep, label="pirecorder") pool.terminate() finally: pool.join() if self.delete: for filein in self.todo: os.remove(filein) lineprint("Deleted all original videofiles..", label="pirecorder") elif self.type in [".jpg", ".jpeg", ".png"]: vidname = commonpref(self.todo) lineprint("Start converting " + str(len(self.todo)) + " images", label="pirecorder") frame_array = [] for filename in self.todo: frame = cv2.imread(filename) frame_array.append(frame) #os.rename(filename, self.outdir+"/"+filename) h, w, _ = frame_array[0].shape if self.outdir != "": vidname = self.outdir + "/" + os.path.basename(vidname) vidout = videowriter(vidname, w, h, self.imgfps, self.resizeval) for i in range(len(frame_array)): vidout.write(frame_array[i]) vidout.release() lineprint("Finished converting " + os.path.basename(vidname), label="pirecorder") else: lineprint("No video or image files found..", label="pirecorder")