def process_video(file_name, n=1): """ iterate over frames of videofile :param file_name: filename :param n:process one out of every n frames-> default 1: take all frames :return:list of finish frames """ fvs = FileVideoStream(file_name).start() #load video cam = cv2.VideoCapture(file_name) fps = cam.get(cv2.CAP_PROP_FPS) #get original fps of video counter = 1 frame_list = [] teller = 0 while fvs.running(): if fvs.more(): teller += 1 frame = fvs.read() if frame is not None: frame_list.append( cv2.resize( frame, (int(frame.shape[1] / 2), int(frame.shape[0] / 2))) ) #append frame to list and resize it: height/2, width/2 counter += 1 else: time.sleep(2) return (frame_list, fps)
def extract(input_path, output_folder, rate): STR_FRAME_PATH = "{}\\frame{}.jpg" video_args = {} video_args["video"] = input_path fvs = FileVideoStream(video_args["video"], queue_size=300).start() time.sleep(1.0) framecount = 0 fps = FPS().start() while fvs.running(): frame = fvs.read() img_raw = None framecount = framecount + 1 if framecount % int(rate) == 0: print("Extrating frame {}".format(framecount), end="\r") cv2.imwrite(STR_FRAME_PATH.format(output_folder, str(framecount)), frame) else: continue fps.update() fps.stop() fvs.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
class VideoSource (object): def __init__ (self, video_file, log, use_pi_camera = True, resolution=(320, 200), framerate = 30, night = False): self.filename = video_file self.log = log self.use_pi_camera = use_pi_camera self.resolution = resolution self.framerate = framerate self.night = night self.fvs = None self.stream = None self._done = False def start (self): if self.filename is not None: self.log.debug('Video file: %s', self.filename) self.fvs = FileVideoStream(self.filename).start() self.stream = self.fvs.stream time.sleep(1.0) else: if self.use_pi_camera: self.log.debug('Pi Camera (%d %d)', self.resolution[0], self.resolution[1]) self.stream = VideoStream(src=0, usePiCamera=True, resolution=self.resolution, framerate=self.framerate, sensor_mode=5 ).start() else: self.log.debug('Web Camera') self.stream = cv2.VideoCapture(0) self.stream.set(cv2.CAP_PROP_BUFFERSIZE, 2) self.resolution = ( self.stream.get(cv2.CAP_PROP_FRAME_WIDTH), self.stream.get(cv2.CAP_PROP_FRAME_HEIGHT) ) self.framerate = self.stream.get(cv2.CAP_PROP_FPS) return self.resolution, self.framerate def read(self): if self.filename: frame = self.fvs.read() else: frame = self.stream.read() return frame def stop (self): if self.filename: self.fvs.stop() else: self.stream.stop() self._done = True def done(self): # check to see if video is still running running = (self.filename and self.fvs.running()) or True self._done = not running return self._done
def extract(input_path, output_folder, rate): STR_FRAME_PATH = "{}\\frame{}.jpg" video_args = {} video_args["video"] = input_path fvs = FileVideoStream(video_args["video"], queue_size=300).start() time.sleep(1.0) framecount = 0 fps = FPS().start() net = cv2.dnn.readNetFromCaffe(args.face_prototxt, args.face_model) while fvs.running(): frame = fvs.read() img_raw = None framecount = framecount + 1 if framecount % int(rate) == 0: print("Extrating frame {}".format(framecount), end="\r") path = "{}\\{}{}.jpg".format( Path(args.input).parent, Path(args.input).stem, framecount) faces = extract_faces_from_image(frame, path, args.confidence, net) faces_to_save = [] for face in faces: gender = get_gender(face, args.gender_model, args.gender_proto) if gender["gender"] == "Female" and gender["conf"] > 0.98: faces_to_save.append(face) save_faces_from_image(faces_to_save, path) else: continue fps.update() fps.stop() fvs.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
def cli(ctx, sink, fp_in, opt_size_type): """Add mappings data to chain""" # ------------------------------------------------------------- # imports import os import logging import cv2 as cv from tqdm import tqdm import imutils from vframe.settings.paths import Paths from vframe.utils import file_utils, logger_utils from vframe.models.chair_item import ChairItem, PhotoChairItem, VideoKeyframeChairItem from vframe.utils import logger_utils, im_utils # --------------------------------------------------------------- # init log = logger_utils.Logger.getLogger() log.info('fp_in: {}'.format(fp_in)) # assume video ext = file_utils.get_ext(fp_in) media_format = file_utils.ext_media_format(ext) # enum type # check file existence if not Path(fp_in).exists(): log.error('file not found: {}'.format(fp_in)) return if media_format == types.MediaFormat.PHOTO: log.debug('photo type') sink.send(PhotoChairItem(ctx, fp_in)) elif media_format == types.MediaFormat.VIDEO: log.debug('video type') import time from imutils.video import FileVideoStream opt_size = cfg.IMAGE_SIZES[opt_size_type] # TODO this should be in "add_images" command def frame_transform(frame): return im_utils.resize(frame, width=opt_size) fvs = FileVideoStream(fp_in, transform=frame_transform).start() time.sleep(1.0) # recommended delay stream = fvs.stream ctx.opts['last_display_ms'] = time.time() ctx.opts['fps'] = stream.get(cv.CAP_PROP_FPS) ctx.opts['mspf'] = int(1 / ctx.opts['fps'] * 1000) # milliseconds per frame # loop over frames from the video file stream frame_idx = 0 while fvs.running(): frame = fvs.read() sink.send(VideoKeyframeChairItem(ctx, frame, frame_idx)) frame_idx += 1
ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", required=True, help="path to input video file") args = vars(ap.parse_args()) # start the file video stream thread and allow the buffer to # start to fill print("[INFO] starting video file thread...") fvs = FileVideoStream(args["video"], transform=filterFrame).start() time.sleep(1.0) # start the FPS timer fps = FPS().start() # loop over frames from the video file stream while fvs.running(): # grab the frame from the threaded video file stream, resize # it, and convert it to grayscale (while still retaining 3 # channels) frame = fvs.read() # Relocated filtering into producer thread with transform=filterFrame # Python 2.7: FPS 92.11 -> 131.36 # Python 3.7: FPS 41.44 -> 50.11 #frame = filterFrame(frame) # display the size of the queue on the frame cv2.putText(frame, "Queue Size: {}".format(fvs.Q.qsize()), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2) # show the frame and update the FPS counter
class movement_direction: def __init__(self, video_source_info, user_roi): self.source_info = video_source_info self.source = None if self.source_info == '0' or self.source_info == '1': self.source = 'Camera' elif isinstance(self.source_info, str) and Path( self.source_info).exists() and Path(sys.argv[1]).is_file(): self.source = self.source_info self._is_valid = not (self.source is None) self.frame_count = 0 self.prev_frame = None self.prev_angle = None self.current_angle = None self.angle_estimate_available = False self.angle_posts = dict(Right=75, Left=120) self.angle_diff_threshold = 7 self.current_state = State.eUnknown self.prev_state = self.current_state self.logger = get_logger() self.angle_states = {} self.angle_states[State.eRight] = 'Right' self.angle_states[State.eLeft] = 'Left' self.angle_states[State.eSame] = 'Straight' self.angle_states[State.eUnknown] = 'Unknown' ''' Initialize Capture and set up region of interest ''' if self.source == 'Camera': self.cap = WebcamVideoStream(src=int(self.source_info)) else: self.cap = FileVideoStream(self.source_info) self.cap.start() frame = self.cap.read() self.prev_frame = frame.copy() shape = self.prev_frame.shape time.sleep(2) (self.source_height, self.source_width) = self.prev_frame.shape[:2] self._is_loaded = True self.logger.info('Source is ' + self.source) video_roi = user_roi if self.source == 'Camera': camera_roi = dict(row_low=0, row_high=self.source_height - 1, column_low=0, column_high=self.source_width - 1) video_roi = camera_roi self.logger.info(video_roi) self.row_range = (video_roi['row_low'], video_roi['row_high']) self.column_range = (video_roi['column_low'], video_roi['column_high']) self.settings = initialize_settings_from_video_roi(video_roi) self.width = video_roi['column_high'] - video_roi['column_low'] self.height = video_roi['row_high'] - video_roi['row_low'] assert (self.width <= self.source_width) assert (self.height <= self.source_height) self.logger.info((self.source_width, self.source_height)) ''' Initialize tracking parameters ''' self.feature_params = self.settings['feature_params'] self.lk_params = self.settings['lk_params'] self.max_dist = self.settings['max_distance'] self.prev_frame = None self.keypoint_dist = 0 self.min_features = self.settings['min_features'] self.old_points = [] self.new_points = [] self.keypoints = [] self.display = None self.debug = False self.direction = [] self.avg_angle = None self.show_vectors = False self.show_axis = False def is_loaded(self): return self._is_loaded def is_valid(self): return self._is_valid def run(self): frame = self.prev_frame.copy() self.prev_frame = self.prepare_frame(frame) self.logger.info(('frame: ', self.frame_count)) self.frame_count = self.frame_count + 1 cv.namedWindow('Frame', cv.WINDOW_NORMAL) while self.cap.running(): captured_frame = self.cap.read() if not (captured_frame is None): self.frame_count = self.frame_count + 1 frame = self.prepare_frame(captured_frame) assert (not (self.prev_frame is None)) self.update_features() self.get_flow(frame) self.prev_frame = frame.copy() # self.draw_tracks( self.keypoints, self.new_points) cv.imshow("Frame", self.display) def prepare_frame(self, frame): frame = frame[self.row_range[0]:self.row_range[1], self.column_range[0]:self.column_range[1]] self.display = frame.copy() frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY) return frame def get_features(self): self.keypoint_dist = 0 # collect features on the prev frame and compute its geometric median self.old_points = cv.goodFeaturesToTrack(self.prev_frame, mask=None, **self.feature_params) self.keypoints = np.copy(self.old_points) def update_features(self): # if moved too much re create features on the prev frame if self.keypoint_dist > self.max_dist: self.get_features() def set_state(_instant_angle): if _instant_angle <= self.angle_posts['Right']: self.current_state = State.eRight elif _instant_angle >= self.angle_posts['Left']: self.current_state = State.eLeft else: self.current_state = State.eSame if self.debug: self.logger.debug('max distance passed: reset ') avg_angle = self.measure_tracks(self.keypoints, self.new_points) avg_angle = math.degrees(avg_angle) % 360 self.direction.append(avg_angle) instant_angle = int(np.average(self.direction)) if self.prev_angle is None: self.prev_angle = instant_angle self.prev_state = State.eUnknown self.current_angle = instant_angle diff = self.current_angle - self.prev_angle ok = diff < self.angle_diff_threshold if ok and self.current_state == self.prev_state: self.current_state = State.eSame else: set_state(instant_angle) self.prev_angle = self.current_angle self.prev_state = self.current_state ## determine current direction: ## difference = current - prev ## if difference < 0 threshold and current is not Unknow ==> Straight ## if prev != current ==> current self.logger.info(('frame, direction:', self.frame_count, instant_angle, self.current_state)) # if few new points create features on the prev frame elif len(self.new_points) < self.min_features: self.get_features() if self.debug: self.logger.debug('copied old points to keypoints ') else: # check number of features in each quadrant to ensure a good distribution of features across entire image nw = ne = sw = se = 0 w = self.width h = self.height for x, y in self.new_points: if x > w // 2: if y > h // 2: se += 1 else: ne += 1 else: if y > h // 2: sw += 1 else: nw += 1 self.num_features = min((nw, ne)) if self.num_features < self.min_features // 4: self.get_features() # if self.debug: self.logger.debug('too few features reset ') else: # just copy new points to old points dim = np.shape(self.new_points) self.old_points = np.reshape(self.new_points, (-1, 1, 2)) if self.debug: self.logger.debug('ok') def get_flow(self, frame): self.new_points, self.status, self.error = cv.calcOpticalFlowPyrLK( self.prev_frame, frame, self.old_points, None, **self.lk_params) self.keypoints = np.reshape( self.keypoints, (-1, 1, 2)) # TODO find out why this is necessary?! self.old_points = self.old_points[self.status == 1] self.new_points = self.new_points[self.status == 1] self.keypoints = self.keypoints[self.status == 1] self.keypoint_dist += self.get_mean_distance_2d( self.old_points, self.new_points) def get_mean_distance_2d(self, features1, features2): num_features = min((len(features1), len(features2))) features1 = np.reshape(features1, (num_features, 2)) features2 = np.reshape(features2, (num_features, 2)) features = zip(features1, features2) n = 0 dist = 0 for f1, f2 in features: dx = f1[0] - f2[0] dy = f1[1] - f2[1] d = math.sqrt(dx**2 + dy**2) dist += d n += 1 if n == 0: return 0 dist /= n return dist def draw_direction(self): if self.prev_state != State.eUnknown and self.current_state != State.eUnknown: direction = self.angle_states[self.current_state] cv.putText(self.display, direction, (self.width // 2, self.height // 2), cv.FONT_HERSHEY_DUPLEX, 2, (225, 0, 0), 7) def draw_tracks(self, points1, points2): if self.show_vectors: for i, (new, old) in enumerate(zip(points1, points2)): a, b = new.ravel() c, d = old.ravel() cl = (0, 255, 0) if a < self.width / 2: cl = (255, 0, 0) frame = cv.line(self.display, (c, d), (a, b), cl, 1) cv.circle(self.display, (a, b), 5, cl, 0, 3) self.draw_direction() cv.putText(self.display, str(self.frame_count), (self.width // 16, (15 * self.height) // 16), cv.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) if self.show_axis: cv.line(self.display, (0, self.height // 2), (self.width, self.height // 2), (255, 0, 0), 1) cv.line(self.display, (self.width // 2, 0), (self.width // 2, self.height), (255, 0, 0), 1) def measure_tracks(self, points1, points2): angles = [] for i, (new, old) in enumerate(zip(points1, points2)): a, b = new.ravel() c, d = old.ravel() line = [c, d, a, b] angle = get_line_angle(line) angles.append(angle) angles = np.asanyarray(angles) mean_angle = np.arctan2(np.sin(angles).mean(), np.cos(angles).mean()) if mean_angle < 0: mean_angle = math.pi + math.pi + mean_angle return mean_angle
class FlightTab(Tab, flight_tab_class): uiSetupReadySignal = pyqtSignal() _motor_data_signal = pyqtSignal(int, object, object) _imu_data_signal = pyqtSignal(int, object, object) _baro_data_signal = pyqtSignal(int, object, object) _input_updated_signal = pyqtSignal(float, float, float, float) _rp_trim_updated_signal = pyqtSignal(float, float) _emergency_stop_updated_signal = pyqtSignal(bool) _assisted_control_updated_signal = pyqtSignal(bool) _heighthold_input_updated_signal = pyqtSignal(float, float, float, float) _hover_input_updated_signal = pyqtSignal(float, float, float, float) _log_error_signal = pyqtSignal(object, str) # UI_DATA_UPDATE_FPS = 10 connectionFinishedSignal = pyqtSignal(str) disconnectedSignal = pyqtSignal(str) _limiting_updated = pyqtSignal(bool, bool, bool) def __init__(self, tabWidget, helper, *args): super(FlightTab, self).__init__(*args) self.setupUi(self) self.tabName = "Flight Control" self.menuName = "Flight Control" self.tabWidget = tabWidget self.helper = helper self.isConnected = False self.disconnectedSignal.connect(self.disconnected) self.connectionFinishedSignal.connect(self.connected) # Incomming signals self.helper.cf.connected.add_callback( self.connectionFinishedSignal.emit) self.helper.cf.disconnected.add_callback(self.disconnectedSignal.emit) self._input_updated_signal.connect(self.updateInputControl) self.helper.inputDeviceReader.input_updated.add_callback( self._input_updated_signal.emit) self._rp_trim_updated_signal.connect(self.calUpdateFromInput) self.helper.inputDeviceReader.rp_trim_updated.add_callback( self._rp_trim_updated_signal.emit) self._emergency_stop_updated_signal.connect(self.updateEmergencyStop) self.helper.inputDeviceReader.emergency_stop_updated.add_callback( self._emergency_stop_updated_signal.emit) self.helper.inputDeviceReader.heighthold_input_updated.add_callback( self._heighthold_input_updated_signal.emit) self._heighthold_input_updated_signal.connect( self._heighthold_input_updated) self.helper.inputDeviceReader.hover_input_updated.add_callback( self._hover_input_updated_signal.emit) self._hover_input_updated_signal.connect(self._hover_input_updated) self.helper.inputDeviceReader.assisted_control_updated.add_callback( self._assisted_control_updated_signal.emit) self._assisted_control_updated_signal.connect( self._assisted_control_updated) self._imu_data_signal.connect(self._imu_data_received) self._baro_data_signal.connect(self._baro_data_received) self._motor_data_signal.connect(self._motor_data_received) self._log_error_signal.connect(self._logging_error) # Connect UI signals that are in this tab self.flightModeCombo.currentIndexChanged.connect(self.flightmodeChange) self.minThrust.valueChanged.connect(self.minMaxThrustChanged) self.maxThrust.valueChanged.connect(self.minMaxThrustChanged) self.thrustLoweringSlewRateLimit.valueChanged.connect( self.thrustLoweringSlewRateLimitChanged) self.slewEnableLimit.valueChanged.connect( self.thrustLoweringSlewRateLimitChanged) self.targetCalRoll.valueChanged.connect(self._trim_roll_changed) self.targetCalPitch.valueChanged.connect(self._trim_pitch_changed) self.maxAngle.valueChanged.connect(self.maxAngleChanged) self.maxYawRate.valueChanged.connect(self.maxYawRateChanged) self.uiSetupReadySignal.connect(self.uiSetupReady) self.clientXModeCheckbox.toggled.connect(self.changeXmode) self.isInCrazyFlightmode = False self.uiSetupReady() self.clientXModeCheckbox.setChecked(Config().get("client_side_xmode")) self.crazyflieXModeCheckbox.clicked.connect( lambda enabled: self.helper.cf.param.set_value( "flightmode.x", str(enabled))) self.helper.cf.param.add_update_callback( group="flightmode", name="xmode", cb=(lambda name, checked: self.crazyflieXModeCheckbox.setChecked( eval(checked)))) self.ratePidRadioButton.clicked.connect( lambda enabled: self.helper.cf.param.set_value( "flightmode.ratepid", str(enabled))) self.angularPidRadioButton.clicked.connect( lambda enabled: self.helper.cf.param.set_value( "flightmode.ratepid", str(not enabled))) self._led_ring_headlight.clicked.connect( lambda enabled: self.helper.cf.param.set_value( "ring.headlightEnable", str(enabled))) self.helper.cf.param.add_update_callback( group="flightmode", name="ratepid", cb=(lambda name, checked: self.ratePidRadioButton.setChecked( eval(checked)))) self.helper.cf.param.add_update_callback( group="cpu", name="flash", cb=self._set_enable_client_xmode) self.helper.cf.param.add_update_callback( group="ring", name="headlightEnable", cb=(lambda name, checked: self._led_ring_headlight.setChecked( eval(checked)))) self._ledring_nbr_effects = 0 self.helper.cf.param.add_update_callback(group="ring", name="effect", cb=self._ring_effect_updated) self.helper.cf.param.add_update_callback( group="imu_sensors", cb=self._set_available_sensors) self.helper.cf.param.all_updated.add_callback(self._all_params_updated) self.logBaro = None self.logAltHold = None self.ai = AttitudeIndicator() self.verticalAttitudeIndicator.addWidget(self.ai) self.splitter.setSizes([1000, 1]) self.targetCalPitch.setValue(Config().get("trim_pitch")) self.targetCalRoll.setValue(Config().get("trim_roll")) self.helper.inputDeviceReader.alt1_updated.add_callback( self.alt1_updated) self.helper.inputDeviceReader.alt2_updated.add_callback( self.alt2_updated) self._tf_state = 0 self._ring_effect = 0 # Connect callbacks for input device limiting of rpöö/pitch/yaw/thust self.helper.inputDeviceReader.limiting_updated.add_callback( self._limiting_updated.emit) self._limiting_updated.connect(self._set_limiting_enabled) self.threads = [] self.goproCamera = None self.fvs = None self.fps = None self.stop = False self.video_window.setVisible(False) self.checkEnableGoPro.stateChanged.connect(self.click_enable_gopro) def click_enable_gopro(self, state): if self.checkEnableGoPro.isChecked(): self.checkEnableGoPro.setText( "EnableGopro. Trying to connect GoPro.") self.stop = False self.gopro_connect() else: self.checkEnableGoPro.setText("EnableGopro") self.stop = True self.video_window.setVisible(False) self.gopro_disconnect() def start_stream(self): self.goproCamera.livestream("stop") self.goproCamera.stream("udp://@127.0.0.1:10000", quality="high") def stop_stream(self): self.goproCamera.livestream("stop") def stop_threads(self): while len(self.threads) > 0: for thread in self.threads: if thread.is_alive(): thread.join() self.threads.remove(thread) def play_stream(self): self.fvs = FileVideoStream('udp://@127.0.0.1:10000').start() self.fps = FPS().start() while self.fvs.running(): if self.stop: break try: frame = self.fvs.read() frame = imutils.resize(frame, width=self.video_window.width()) #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) height, width, channel = frame.shape bytesPerLine = 3 * width qimg = QImage(frame.data, width, height, bytesPerLine, QImage.Format_RGB888).rgbSwapped() pixmap = QPixmap(qimg) if not self.video_window.isVisible(): self.checkEnableGoPro.setText("EnableGopro") self.video_window.setVisible(True) self.video_window.setPixmap(pixmap) except Exception as exc: pass if self.fvs.Q.qsize( ) < 2: # If we are low on frames, give time to producer time.sleep( 0.001) # Ensures producer runs now, so 2 is sufficient self.fps.update() QApplication.processEvents() self.fps.stop() self.fvs.stop() cv2.destroyAllWindows() def gopro_connect(self): stream_stop_threads = Thread(target=self.stop_threads, args=()) stream_stop_threads.start() if not self.goproCamera: self.goproCamera = GoProCamera.GoPro(constants.gpcontrol) stream_start_threads = Thread(target=self.start_stream, args=()) stream_play_thread = Thread(target=self.play_stream, args=()) self.threads.append(stream_start_threads) self.threads.append(stream_play_thread) stream_start_threads.start() stream_play_thread.start() def gopro_disconnect(self): self.stop_stream() stream_stop_threads = Thread(target=self.stop_threads, args=()) stream_stop_threads.start() self.goproCamera = None def _set_enable_client_xmode(self, name, value): if eval(value) <= 128: self.clientXModeCheckbox.setEnabled(True) else: self.clientXModeCheckbox.setEnabled(False) self.clientXModeCheckbox.setChecked(False) def _set_limiting_enabled(self, rp_limiting_enabled, yaw_limiting_enabled, thrust_limiting_enabled): self.maxAngle.setEnabled(rp_limiting_enabled) self.targetCalRoll.setEnabled(rp_limiting_enabled) self.targetCalPitch.setEnabled(rp_limiting_enabled) self.maxYawRate.setEnabled(yaw_limiting_enabled) self.maxThrust.setEnabled(thrust_limiting_enabled) self.minThrust.setEnabled(thrust_limiting_enabled) self.slewEnableLimit.setEnabled(thrust_limiting_enabled) self.thrustLoweringSlewRateLimit.setEnabled(thrust_limiting_enabled) def thrustToPercentage(self, thrust): return ((thrust / MAX_THRUST) * 100.0) def uiSetupReady(self): flightComboIndex = self.flightModeCombo.findText( Config().get("flightmode"), Qt.MatchFixedString) if (flightComboIndex < 0): self.flightModeCombo.setCurrentIndex(0) self.flightModeCombo.currentIndexChanged.emit(0) else: self.flightModeCombo.setCurrentIndex(flightComboIndex) self.flightModeCombo.currentIndexChanged.emit(flightComboIndex) def _logging_error(self, log_conf, msg): QMessageBox.about( self, "Log error", "Error when starting log config [%s]: %s" % (log_conf.name, msg)) def _motor_data_received(self, timestamp, data, logconf): if self.isVisible(): self.actualM1.setValue(data["motor.m1"]) self.actualM2.setValue(data["motor.m2"]) self.actualM3.setValue(data["motor.m3"]) self.actualM4.setValue(data["motor.m4"]) def _baro_data_received(self, timestamp, data, logconf): if self.isVisible(): estimated_z = data[LOG_NAME_ESTIMATED_Z] asl = data["baro.asl"] temp = data["baro.temp"] pressure = data["baro.pressure"] self.actualHeight.setText(("%.2f" % estimated_z)) self.ai.setBaro(estimated_z, self.is_visible()) self.ai.setAsl(asl, self.is_visible()) self.ai.setTemp(temp, self.is_visible()) self.ai.setPressure(pressure, self.is_visible()) def _heighthold_input_updated(self, roll, pitch, yaw, height): if (self.isVisible() and (self.helper.inputDeviceReader.get_assisted_control() == self.helper.inputDeviceReader.ASSISTED_CONTROL_HEIGHTHOLD)): self.targetRoll.setText(("%0.2f deg" % roll)) self.targetPitch.setText(("%0.2f deg" % pitch)) self.targetYaw.setText(("%0.2f deg/s" % yaw)) self.targetHeight.setText(("%.2f m" % height)) self.ai.setHover(height, self.is_visible()) def _hover_input_updated(self, vx, vy, yaw, height): if (self.isVisible() and (self.helper.inputDeviceReader.get_assisted_control() == self.helper.inputDeviceReader.ASSISTED_CONTROL_HOVER)): self.targetRoll.setText(("%0.2f m/s" % vy)) self.targetPitch.setText(("%0.2f m/s" % vx)) self.targetYaw.setText(("%0.2f deg/s" % yaw)) self.targetHeight.setText(("%.2f m" % height)) self.ai.setHover(height, self.is_visible()) def _imu_data_received(self, timestamp, data, logconf): if self.isVisible(): self.actualRoll.setText(("%.2f" % data["stabilizer.roll"])) self.actualPitch.setText(("%.2f" % data["stabilizer.pitch"])) self.actualYaw.setText(("%.2f" % data["stabilizer.yaw"])) self.actualThrust.setText( "%.2f%%" % self.thrustToPercentage(data["stabilizer.thrust"])) self.ai.setRollPitch(-data["stabilizer.roll"], data["stabilizer.pitch"], self.is_visible()) def connected(self, linkURI): # IMU & THRUST self.isConnected = True lg = LogConfig("Stabilizer", Config().get("ui_update_period")) lg.add_variable("stabilizer.roll", "float") lg.add_variable("stabilizer.pitch", "float") lg.add_variable("stabilizer.yaw", "float") lg.add_variable("stabilizer.thrust", "uint16_t") try: self.helper.cf.log.add_config(lg) lg.data_received_cb.add_callback(self._imu_data_signal.emit) lg.error_cb.add_callback(self._log_error_signal.emit) lg.start() except KeyError as e: logger.warning(str(e)) except AttributeError as e: logger.warning(str(e)) # MOTOR lg = LogConfig("Motors", Config().get("ui_update_period")) lg.add_variable("motor.m1") lg.add_variable("motor.m2") lg.add_variable("motor.m3") lg.add_variable("motor.m4") try: self.helper.cf.log.add_config(lg) lg.data_received_cb.add_callback(self._motor_data_signal.emit) lg.error_cb.add_callback(self._log_error_signal.emit) lg.start() except KeyError as e: logger.warning(str(e)) except AttributeError as e: logger.warning(str(e)) def _set_available_sensors(self, name, available): logger.info("[%s]: %s", name, available) available = eval(available) self.actualHeight.setEnabled(True) self.helper.inputDeviceReader.set_alt_hold_available(available) if not self.logBaro: # The sensor is available, set up the logging self.logBaro = LogConfig("Baro", 200) self.logBaro.add_variable(LOG_NAME_ESTIMATED_Z, "float") self.logBaro.add_variable("baro.asl", "float") self.logBaro.add_variable("baro.temp", "float") self.logBaro.add_variable("baro.pressure", "float") try: self.helper.cf.log.add_config(self.logBaro) self.logBaro.data_received_cb.add_callback( self._baro_data_signal.emit) self.logBaro.error_cb.add_callback(self._log_error_signal.emit) self.logBaro.start() except KeyError as e: logger.warning(str(e)) except AttributeError as e: logger.warning(str(e)) def disconnected(self, linkURI): self.isConnected = False self.ai.setRollPitch(0, 0) self.actualM1.setValue(0) self.actualM2.setValue(0) self.actualM3.setValue(0) self.actualM4.setValue(0) self.actualRoll.setText("") self.actualPitch.setText("") self.actualYaw.setText("") self.actualThrust.setText("") self.actualHeight.setText("") self.targetHeight.setText("Not Set") self.ai.setHover(0, self.is_visible()) self.targetHeight.setEnabled(False) self.actualHeight.setEnabled(False) self.clientXModeCheckbox.setEnabled(False) self.logBaro = None self.logAltHold = None self._led_ring_effect.setEnabled(False) self._led_ring_effect.clear() try: self._led_ring_effect.currentIndexChanged.disconnect( self._ring_effect_changed) except TypeError: # Signal was not connected pass self._led_ring_effect.setCurrentIndex(-1) self._led_ring_headlight.setEnabled(False) try: self._assist_mode_combo.currentIndexChanged.disconnect( self._assist_mode_changed) except TypeError: # Signal was not connected pass self._assist_mode_combo.setEnabled(False) self._assist_mode_combo.clear() def minMaxThrustChanged(self): self.helper.inputDeviceReader.min_thrust = self.minThrust.value() self.helper.inputDeviceReader.max_thrust = self.maxThrust.value() if (self.isInCrazyFlightmode is True): Config().set("min_thrust", self.minThrust.value()) Config().set("max_thrust", self.maxThrust.value()) def thrustLoweringSlewRateLimitChanged(self): self.helper.inputDeviceReader.thrust_slew_rate = ( self.thrustLoweringSlewRateLimit.value()) self.helper.inputDeviceReader.thrust_slew_limit = ( self.slewEnableLimit.value()) if (self.isInCrazyFlightmode is True): Config().set("slew_limit", self.slewEnableLimit.value()) Config().set("slew_rate", self.thrustLoweringSlewRateLimit.value()) def maxYawRateChanged(self): logger.debug("MaxYawrate changed to %d", self.maxYawRate.value()) self.helper.inputDeviceReader.max_yaw_rate = self.maxYawRate.value() if (self.isInCrazyFlightmode is True): Config().set("max_yaw", self.maxYawRate.value()) def maxAngleChanged(self): logger.debug("MaxAngle changed to %d", self.maxAngle.value()) self.helper.inputDeviceReader.max_rp_angle = self.maxAngle.value() if (self.isInCrazyFlightmode is True): Config().set("max_rp", self.maxAngle.value()) def _trim_pitch_changed(self, value): logger.debug("Pitch trim updated to [%f]" % value) self.helper.inputDeviceReader.trim_pitch = value Config().set("trim_pitch", value) def _trim_roll_changed(self, value): logger.debug("Roll trim updated to [%f]" % value) self.helper.inputDeviceReader.trim_roll = value Config().set("trim_roll", value) def calUpdateFromInput(self, rollCal, pitchCal): logger.debug("Trim changed on joystick: roll=%.2f, pitch=%.2f", rollCal, pitchCal) self.targetCalRoll.setValue(rollCal) self.targetCalPitch.setValue(pitchCal) def updateInputControl(self, roll, pitch, yaw, thrust): self.targetRoll.setText(("%0.2f deg" % roll)) self.targetPitch.setText(("%0.2f deg" % pitch)) self.targetYaw.setText(("%0.2f deg/s" % yaw)) self.targetThrust.setText( ("%0.2f %%" % self.thrustToPercentage(thrust))) self.thrustProgress.setValue(thrust) if not self.isConnected: self.ai.setRollPitch(-roll, pitch, self.is_visible()) def setMotorLabelsEnabled(self, enabled): self.M1label.setEnabled(enabled) self.M2label.setEnabled(enabled) self.M3label.setEnabled(enabled) self.M4label.setEnabled(enabled) def emergencyStopStringWithText(self, text): return ("<html><head/><body><p>" "<span style='font-weight:600; color:#7b0005;'>{}</span>" "</p></body></html>".format(text)) def updateEmergencyStop(self, emergencyStop): if emergencyStop: self.setMotorLabelsEnabled(False) self.emergency_stop_label.setText( self.emergencyStopStringWithText("Kill switch active")) else: self.setMotorLabelsEnabled(True) self.emergency_stop_label.setText("") def flightmodeChange(self, item): Config().set("flightmode", str(self.flightModeCombo.itemText(item))) logger.debug("Changed flightmode to %s", self.flightModeCombo.itemText(item)) self.isInCrazyFlightmode = False if (item == 0): # Normal self.maxAngle.setValue(Config().get("normal_max_rp")) self.maxThrust.setValue(Config().get("normal_max_thrust")) self.minThrust.setValue(Config().get("normal_min_thrust")) self.slewEnableLimit.setValue(Config().get("normal_slew_limit")) self.thrustLoweringSlewRateLimit.setValue( Config().get("normal_slew_rate")) self.maxYawRate.setValue(Config().get("normal_max_yaw")) if (item == 1): # Advanced self.maxAngle.setValue(Config().get("max_rp")) self.maxThrust.setValue(Config().get("max_thrust")) self.minThrust.setValue(Config().get("min_thrust")) self.slewEnableLimit.setValue(Config().get("slew_limit")) self.thrustLoweringSlewRateLimit.setValue( Config().get("slew_rate")) self.maxYawRate.setValue(Config().get("max_yaw")) self.isInCrazyFlightmode = True if (item == 0): newState = False else: newState = True self.maxThrust.setEnabled(newState) self.maxAngle.setEnabled(newState) self.minThrust.setEnabled(newState) self.thrustLoweringSlewRateLimit.setEnabled(newState) self.slewEnableLimit.setEnabled(newState) self.maxYawRate.setEnabled(newState) def _assist_mode_changed(self, item): mode = None if (item == 0): # Altitude hold mode = JoystickReader.ASSISTED_CONTROL_ALTHOLD if (item == 1): # Position hold mode = JoystickReader.ASSISTED_CONTROL_POSHOLD if (item == 2): # Position hold mode = JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD if (item == 3): # Position hold mode = JoystickReader.ASSISTED_CONTROL_HOVER self.helper.inputDeviceReader.set_assisted_control(mode) Config().set("assistedControl", mode) def _assisted_control_updated(self, enabled): if self.helper.inputDeviceReader.get_assisted_control() == \ JoystickReader.ASSISTED_CONTROL_POSHOLD: self.targetThrust.setEnabled(not enabled) self.targetRoll.setEnabled(not enabled) self.targetPitch.setEnabled(not enabled) elif ((self.helper.inputDeviceReader.get_assisted_control() == JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD) or (self.helper.inputDeviceReader.get_assisted_control() == JoystickReader.ASSISTED_CONTROL_HOVER)): self.targetThrust.setEnabled(not enabled) self.targetHeight.setEnabled(enabled) else: self.helper.cf.param.set_value("flightmode.althold", str(enabled)) @pyqtSlot(bool) def changeXmode(self, checked): self.helper.cf.commander.set_client_xmode(checked) Config().set("client_side_xmode", checked) logger.info("Clientside X-mode enabled: %s", checked) def alt1_updated(self, state): if state: new_index = (self._ring_effect + 1) % (self._ledring_nbr_effects + 1) self.helper.cf.param.set_value("ring.effect", str(new_index)) def alt2_updated(self, state): self.helper.cf.param.set_value("ring.headlightEnable", str(state)) def _all_params_updated(self): self._ring_populate_dropdown() self._populate_assisted_mode_dropdown() def _ring_populate_dropdown(self): try: nbr = int(self.helper.cf.param.values["ring"]["neffect"]) current = int(self.helper.cf.param.values["ring"]["effect"]) except KeyError: return # Used only in alt1_updated function self._ring_effect = current self._ledring_nbr_effects = nbr hardcoded_names = { 0: "Off", 1: "White spinner", 2: "Color spinner", 3: "Tilt effect", 4: "Brightness effect", 5: "Color spinner 2", 6: "Double spinner", 7: "Solid color effect", 8: "Factory test", 9: "Battery status", 10: "Boat lights", 11: "Alert", 12: "Gravity", 13: "LED tab", 14: "Color fader", 15: "Link quality" } for i in range(nbr + 1): name = "{}: ".format(i) if i in hardcoded_names: name += hardcoded_names[i] else: name += "N/A" self._led_ring_effect.addItem(name, i) self._led_ring_effect.currentIndexChanged.connect( self._ring_effect_changed) self._led_ring_effect.setCurrentIndex(current) if int(self.helper.cf.param.values["deck"]["bcLedRing"]) == 1: self._led_ring_effect.setEnabled(True) self._led_ring_headlight.setEnabled(True) def _ring_effect_changed(self, index): self._ring_effect = index if index > -1: i = self._led_ring_effect.itemData(index) logger.info("Changed effect to {}".format(i)) if i != int(self.helper.cf.param.values["ring"]["effect"]): self.helper.cf.param.set_value("ring.effect", str(i)) def _ring_effect_updated(self, name, value): if self.helper.cf.param.is_updated: self._led_ring_effect.setCurrentIndex(int(value)) def _populate_assisted_mode_dropdown(self): self._assist_mode_combo.addItem("Altitude hold", 0) self._assist_mode_combo.addItem("Position hold", 1) self._assist_mode_combo.addItem("Height hold", 2) self._assist_mode_combo.addItem("Hover", 3) heightHoldPossible = False hoverPossible = False if int(self.helper.cf.param.values["deck"]["bcZRanger"]) == 1: heightHoldPossible = True self.helper.inputDeviceReader.set_hover_max_height(1.0) if int(self.helper.cf.param.values["deck"]["bcZRanger2"]) == 1: heightHoldPossible = True self.helper.inputDeviceReader.set_hover_max_height(2.0) if int(self.helper.cf.param.values["deck"]["bcFlow"]) == 1: heightHoldPossible = True hoverPossible = True self.helper.inputDeviceReader.set_hover_max_height(1.0) if int(self.helper.cf.param.values["deck"]["bcFlow2"]) == 1: heightHoldPossible = True hoverPossible = True self.helper.inputDeviceReader.set_hover_max_height(2.0) if not heightHoldPossible: self._assist_mode_combo.model().item(2).setEnabled(False) else: self._assist_mode_combo.model().item(0).setEnabled(False) if not hoverPossible: self._assist_mode_combo.model().item(3).setEnabled(False) else: self._assist_mode_combo.model().item(0).setEnabled(False) self._assist_mode_combo.currentIndexChanged.connect( self._assist_mode_changed) self._assist_mode_combo.setEnabled(True) try: assistmodeComboIndex = Config().get("assistedControl") if assistmodeComboIndex == 3 and not hoverPossible: self._assist_mode_combo.setCurrentIndex(0) self._assist_mode_combo.currentIndexChanged.emit(0) elif assistmodeComboIndex == 0 and hoverPossible: self._assist_mode_combo.setCurrentIndex(3) self._assist_mode_combo.currentIndexChanged.emit(3) elif assistmodeComboIndex == 2 and not heightHoldPossible: self._assist_mode_combo.setCurrentIndex(0) self._assist_mode_combo.currentIndexChanged.emit(0) elif assistmodeComboIndex == 0 and heightHoldPossible: self._assist_mode_combo.setCurrentIndex(2) self._assist_mode_combo.currentIndexChanged.emit(2) else: self._assist_mode_combo.setCurrentIndex(assistmodeComboIndex) self._assist_mode_combo.currentIndexChanged.emit( assistmodeComboIndex) except KeyError: defaultOption = 0 if hoverPossible: defaultOption = 3 elif heightHoldPossible: defaultOption = 2 self._assist_mode_combo.setCurrentIndex(defaultOption) self._assist_mode_combo.currentIndexChanged.emit(defaultOption)
# vs = VideoStream(usePiCamera=True).start() #fileStream = False time.sleep(1.0) x = [] i = 0 with open('EAR_orig_8.csv', 'a', newline='') as myfile: wr = csv.writer(myfile, quoting=csv.QUOTE_ALL) wr.writerow(['index', 'EAR']) ear_prev = 0 # loop over frames from the video stream while True: # if this is a file video stream, then we need to check if # there any more frames left in the buffer to process if fileStream and (not vs.running()): break # grab the frame from the threaded video file stream, resize # it, and convert it to grayscale # channels) frame = vs.read() frame = imutils.resize(frame, width=720) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # detect faces in the grayscale frame rects = detector(gray, 0) fl = 0 # loop over the face detections for rect in rects: