def __init__(self): super(EventProcessor, self).__init__() self.message_handler = MessageHandler() #self.gps = GPS() Message.init(self.message_handler.plugin.address()) Detector.start_plugins() Reactor.add_plugin_events()
def run(self): '''Reads assignments from Assignment_* folders, student numbers from their Assignment_x folder, generates a zip of each students' code files and runs the Detector on it''' assignment_id_map = {} assignments = self.get_folder_names(self.path) database = DatabaseManager() for assignment in assignments: document_assignment_number = self.get_assignment_number(assignment) if document_assignment_number not in (6, 5): continue if document_assignment_number not in assignment_id_map: name = 'Assignment %d' % document_assignment_number assignment_id_map[document_assignment_number] = database.store_assignment(name, name, '2015-01-01') assignment_number = assignment_id_map[document_assignment_number] assignment_path = os.path.join(self.path, assignment) student_numbers = self.get_folder_names(assignment_path) for student_number in student_numbers: student_folder = os.path.join(assignment_path, student_number) output_file = StringIO() zip = zipfile.ZipFile(output_file, 'w') for file in self.get_file_names(student_folder): zip.write(os.path.join(student_folder, file), file) print('zipping: ' + file) zip.close() detector = Detector() detector.run(output_file, assignment_number,student_number)
class DetectorUI(QtGui.QWidget): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) QtCore.QObject.connect(self.ui.startButton,QtCore.SIGNAL("clicked()"), self.start) QtCore.QObject.connect(self.ui.pathButton,QtCore.SIGNAL("clicked()"), self.set_source_file_path) QtCore.QObject.connect(self.ui.patternCheckBox,QtCore.SIGNAL("clicked()"), self.patternClicked) self.detector = Detector() def start(self): if self.detector.isRunning(): self.setWindowTitle('Stopped') self.detector.stop() self.ui.startButton.setText("Start") else: self.setWindowTitle('Running') self.detector.start() self.ui.startButton.setText("Stop") def set_source_file_path(self): dir = os.path.dirname(".") fileName = QtGui.QFileDialog.getOpenFileName (self, "Open data file", dir , "Image Files (*.txt)") #Todo set the txt file as the data source self.ui.pathEdit.setText(fileName) def patternClicked(self): if self.ui.patternCheckBox.isChecked() : #output data pattern print "patern enabeled" else: #output data source print "patern disable"
def __init__(self, modelNb=3): """Load the tensorflow model of VGG16-GAP trained on caltech Keyword arguments: modelNb -- iteration of the model to consider """ dataset_path = '/home/cuda/datasets/perso_db/' trainset_path = dataset_path+'train.pkl' testset_path = dataset_path+'test.pkl' weight_path = '../caffe_layers_value.pickle' model_path = '../models/perso/model-'+str(modelNb) # load labels testset = pickle.load( open(testset_path, "rb") ) self.label_dict = testset.keys() n_labels = len(self.label_dict) # Initialize some tensorflow variables batch_size = 1 self.images_tf = tf.placeholder( tf.float32, [None, 224, 224, 3], name="images") self.labels_tf = tf.placeholder( tf.int64, [None], name='labels') detector = Detector( weight_path, n_labels ) c1,c2,c3,c4,conv5, self.conv6, gap, self.output = detector.inference( self.images_tf ) self.classmap = detector.get_classmap( self.labels_tf, self.conv6 ) self.sess = tf.InteractiveSession() saver = tf.train.Saver() saver.restore( self.sess, model_path )
def main(argv=None): # pylint: disable=unused-argument assert args.ckpt > 0 or args.batch_eval assert args.detect or args.segment, "Either detect or segment should be True" if args.trunk == 'resnet50': net = ResNet depth = 50 if args.trunk == 'resnet101': net = ResNet depth = 101 if args.trunk == 'vgg16': net = VGG depth = 16 net = net(config=net_config, depth=depth, training=False) if args.dataset == 'voc07' or args.dataset == 'voc07+12': loader = VOCLoader('07', 'test') if args.dataset == 'voc12': loader = VOCLoader('12', 'val', segmentation=args.segment) if args.dataset == 'coco': loader = COCOLoader(args.split) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)) as sess: detector = Detector(sess, net, loader, net_config, no_gt=args.no_seg_gt) if args.dataset == 'coco': tester = COCOEval(detector, loader) else: tester = Evaluation(detector, loader, iou_thresh=args.voc_iou_thresh) if not args.batch_eval: detector.restore_from_ckpt(args.ckpt) tester.evaluate_network(args.ckpt) else: log.info('Evaluating %s' % args.run_name) ckpts_folder = CKPT_ROOT + args.run_name + '/' out_file = ckpts_folder + evaluation_logfile max_checked = get_last_eval(out_file) log.debug("Maximum checked ckpt is %i" % max_checked) with open(out_file, 'a') as f: start = max(args.min_ckpt, max_checked+1) ckpt_files = glob(ckpts_folder + '*.data*') folder_has_nums = np.array(list((map(filename2num, ckpt_files))), dtype='int') nums_available = sorted(folder_has_nums[folder_has_nums >= start]) nums_to_eval = [nums_available[-1]] for n in reversed(nums_available): if nums_to_eval[-1] - n >= args.step: nums_to_eval.append(n) nums_to_eval.reverse() for ckpt in nums_to_eval: log.info("Evaluation of ckpt %i" % ckpt) tester.reset() detector.restore_from_ckpt(ckpt) res = tester.evaluate_network(ckpt) f.write(res) f.flush()
def populateUI(self): self.availableObjectsList.addItems(Detector.getDefaultAvailableObjects()) for sourceMode in self.__sourceModes: self.sourceCBox.addItem(sourceMode) for displayMode in self.__displayModes: self.displayCBox.addItem(displayMode) for shapeMode in self.__shapeModes: self.shapeCBox.addItem(shapeMode) for fillMode in self.__fillModes: self.fillCBox.addItem(fillMode) for bgMode in self.__bgModes: self.bgCBox.addItem(bgMode) model = QtGui.QStandardItemModel(self) func = lambda node, parent: self.populateTree(node, parent) Detector.getDefaultObjectsTree().map(model, func) self.objectsTree.setModel(model)
def free_at_position(new_sudoku, y, x): """ This method is returning all available choices in sudoku at current position. """ now_available = Solver.available[:] init_avail = set(now_available) first_step_avail = init_avail.intersection(Detector.free_in_column(new_sudoku, x)) second_step_avail = first_step_avail.intersection(Detector.free_in_row(new_sudoku, y)) third_step_avail = second_step_avail.intersection(Detector.free_in_squere3x3(new_sudoku, y, x)) return list(third_step_avail)
def simulate_basic_with_pods(ptypy_pars_tree=None,sim_pars=None,save=False): """ Basic Simulation """ p = DEFAULT.copy() ppt = ptypy_pars_tree if ppt is not None: p.update(ppt.get('simulation')) if sim_pars is not None: p.update(sim_pars) P = ptypy.core.Ptycho(ppt,level=1) # make a data source that has is basicaly empty P.datasource = make_sim_datasource(P.modelm,p.pos_drift,p.pos_scale,p.pos_noise) P.modelm.new_data() u.parallel.barrier() P.print_stats() # Propagate and apply psf for simulationg partial coherence (if not done so with modes) for name,pod in P.pods.iteritems(): if not pod.active: continue pod.diff += conv(u.abs2(pod.fw(pod.exit)),p.psf) # Filter storage data similar to a detector. if p.detector is not None: Det = Detector(p.detector) save_dtype = Det.dtype for ID,Sdiff in P.diff.S.items(): # get the mask storage too although their content will be overriden Smask = P.mask.S[ID] dat, mask = Det.filter(Sdiff.data) if p.frame_size is not None: hplanes = u.expect2(p.frame_size)-u.expect2(dat.shape[-2:]) dat = u.crop_pad(dat,hplanes,axes=[-2,-1]).astype(dat.dtype) mask = u.crop_pad(mask,hplanes,axes=[-2,-1]).astype(mask.dtype) Sdiff.fill(dat) Smask.fill(mask) else: save_dtype = None if save: P.modelm.collect_diff_mask_meta(save=save,dtype=save_dtype) u.parallel.barrier() return P
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) QtCore.QObject.connect(self.ui.startButton,QtCore.SIGNAL("clicked()"), self.start) QtCore.QObject.connect(self.ui.pathButton,QtCore.SIGNAL("clicked()"), self.set_source_file_path) QtCore.QObject.connect(self.ui.patternCheckBox,QtCore.SIGNAL("clicked()"), self.patternClicked) self.detector = Detector()
def init_detectot(self): assert args.detect or args.segment, "Either detect or segment should be True" assert args.ckpt > 0, "Specify the number of checkpoint" net = ResNet(config=net_config, depth=50, training=False) self.loader = Loader(opj(EVAL_DIR, 'demodemo')) self.detector = Detector(self.sess, net, self.loader, net_config, no_gt=args.no_seg_gt, folder=opj(self.loader.folder, 'output')) self.detector.restore_from_ckpt(args.ckpt)
def is_person(image): det = Detector(image) faces = len(det.face()) print "FACE: ", det.drawColors[det.drawn-1 % len(det.drawColors)], faces uppers = len(det.upper_body()) print "UPPR: ", det.drawColors[det.drawn-1 % len(det.drawColors)], uppers fulls = len(det.full_body()) print "FULL: ", det.drawColors[det.drawn-1 % len(det.drawColors)], fulls peds = len(det.pedestrian()) print "PEDS: ", det.drawColors[det.drawn-1 % len(det.drawColors)], peds det.draw() det.overlay() return faces + uppers + fulls + peds
def __init__(self): rospy.init_node('detection_node') rospy.loginfo("Loading model") self.DET_PATH = os.path.join(os.path.dirname(__file__), 'efficientdet_d1_coco17_tpu-32') self.mydetector = Detector(self.DET_PATH) self.objects = [] self.counter = 10 self.connectPepper()
def __init__(self, proxy_map, startup_check=False): super(SpecificWorker, self).__init__(proxy_map) self.Period = 2000 if startup_check: self.startup_check() else: self.timer.timeout.connect(self.compute) self.timer.start(self.Period) # Load center track, our tracking module opt = opts().init() self.detector = Detector(opt) # Reid reture extractor self.reid_extractor = FeatureExtractor( model_name='shufflenet', model_path='/home/shubh/Downloads/shufflenet-bee1b265.pth.tar', device='cuda')
def test_sliding_window_function(): intruder_1 = IntruderSignal(known_intruder_1) intruder_2 = IntruderSignal(known_intruder_2) radar_signal = RadarSignal(radar_sample) min_hamming, min_hamming_start_index = Detector.sliding_window(radar_signal, intruder_1) assert (min_hamming, min_hamming_start_index) == (8, 1373) min_hamming, min_hamming_start_index = Detector.sliding_window(radar_signal, intruder_2) assert (min_hamming, min_hamming_start_index) == (8, 42)
def __init__(self): self.running = False self.isPaused = False self.detector = Detector() self.frameSource = FrameSource() self.music = Music() self.window = Window() self.finishSounds = { Finishsounds.success: 'mario-victory.wav', Finishsounds.failure: 'siren.wav', Finishsounds.timeIsUp: 'buzzer.wav' } self.soundtrackFile = 'mi-full.wav' self.duration = 30 self.numKeypoints = 0 self.currentKeypoints = None self.previousKeypoints = None
class FrameAnalyzer: def __init__(self, cap=None): self.detector = Detector() self.color_counts = {"red": 0, "yellow": 0, "green": 0, "orange": 0, "white": 0, "black": 0, "blue": 0} self.detected = 0 self.line_offset = 6 if cap is not None: self.pos_line = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) * 0.763) #Posição da linha de contagem else: self.pos_line = 300 print("analyzer initialized") def reset(self): self.color_counts = {"red": 0, "yellow": 0, "green": 0, "orange": 0, "white": 0, "black": 0, "blue": 0} self.detected = 0 def analyze(self, frame): frame_ = frame.copy() coordinates = self.detector.detect(frame) if coordinates is None: return #print(self.color_counts) for c1, c2 in coordinates: roi = frame_[c1[1]:c2[1], c1[0]:c2[0], :] color_histogram_feature_extraction.color_histogram_of_test_image(roi) color = knn_classifier.main('training.data', 'test.data') y = (c1[1] + c2[1]) / 2 if y<(self.pos_line+self.line_offset) and y>(self.pos_line-self.line_offset): self.color_counts[color] +=1 self.detected += 1 cv2.line(frame, (0, self.pos_line ), (frame.shape[1], self.pos_line), (230, 126, 34), 3) # rendering cv2.rectangle(frame, c1, c2, (0,0,0), 2) t_size = cv2.getTextSize(color, cv2.FONT_HERSHEY_PLAIN, 1 , 1)[0] c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4 cv2.rectangle(frame, c1, c2,(0,0,0),-1) cv2.putText(frame, color, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225,255,255], 1) def plot_results(self, path='output/result.png'): colors = [] colors.append(self.color_counts["red"]) colors.append(self.color_counts["yellow"]) colors.append(self.color_counts["green"]) colors.append(self.color_counts["orange"]) colors.append(self.color_counts["white"]) colors.append(self.color_counts["black"]) colors.append(self.color_counts["blue"]) bar_draw(colors, path)
def load_modules(): modules = {} # load detectors from database from detector import Detector Detector.load_to_dict(modules) # load alarm from database from alarm import Alarm Alarm.load_to_dict(modules) # load rfid from rfid import Rfid Rfid.load_to_dict(modules) from door import Door Door.load_to_dict(modules) return modules
def __init__(self, parent=None): super(Window, self).__init__(parent) self.detector = Detector() self.mediaThread = MediaThread(self) sys.stdout = common.EmittingStream( textWritten=self.normalOutputWritten) self.debugSignal.connect(self.debugTable) self.currentFrame = None self.bgColor = QColor(255, 255, 255) self.bgPath = '' self.classifiersParameters = {} self.setupUI() self.populateUI() self.connectUI() self.initUI()
def __init__(self): self.corner_detection_model = Detector( path_to_model='./models/identity_corner/model.tflite', path_to_labels='./models/identity_corner/label_map.pbtxt', nms_threshold=0.2, score_threshold=0.3) self.text_detection_model = Detector( path_to_model='./models/identity_card/model.tflite', path_to_labels='./models/identity_card/label_map.pbtxt', nms_threshold=0.2, score_threshold=0.2) self.text_detection_discharge = DetectorTF2( path_to_model='./models/discharge_record', path_to_labels='./models/discharge_record/label_map.pbtxt', nms_threshold=0.33, score_threshold=0.33) self.text_recognition_model = TextRecognition( path_to_checkpoint='./models/text_recogintion/transformerocr.pth')
def __init__(self, env, video_device): try: self.API_ENDPOINT = env['ApiEndpoint'] self.FACE_AREA_THRESHOLD = env['FaceAreaThreshold'] self.NAME_TTL_SEC = env['NameTtlSec'] self.FACE_SIMILARITY_THRESHOLD = env['FaceSimilarityThreshold'] self.COGNITO_USERPOOL_ID = env['CognitoUserPoolId'] self.COGNITO_USERPOOL_CLIENT_ID = env['CognitoUserPoolClientId'] self.REGION = env['Region'] except KeyError: print('Invalid config file') raise self.recent_name_list = [] self.registered_name_set = set() self.video_capture = VideoCapture(env, video_device) self.detector = Detector(env) self.viewer = Viewer(env)
def __init__(self): rospy.init_node('crazyflie_tracker') self.counter = 0 self.countNotFound = 0 self.pub_tf = tf.TransformBroadcaster() self.bridge = CvBridge() self.cf_state = 'idle' self.cf_cmd_vel = Twist() path = '/home/potix2/sampling' fps = 20 self.detector = Detector(CaptureCamera(path, 640, 480, fps)) self.detector.add_capture_callback(self._capture_state) self.detector.add_capture_callback(self._capture_cmd_vel) self.detector.set_mask_range_callback(self._mask_range) # publish transform rate at 50Hz self.rate = rospy.Rate(50.0) self.target_u = 0 self.target_v = 0 self.target_d = 0 self.last_d = 0 #self.r = 0 self.y = 0 self.r = -1.5708 #self.y = -3.1415 self.p = 0 # subscribe to kinect image messages rospy.wait_for_message("/camera/rgb/camera_info", CameraInfo) rospy.wait_for_message("/camera/depth/camera_info", CameraInfo) # Subscribe to Realsense R200 camera_info to get image frame height and width rospy.Subscriber('/camera/rgb/camera_info', CameraInfo, self.camera_data, queue_size=1) rospy.Subscriber("/camera/rgb/image_rect_color", Image, self.image_callback, queue_size=1) rospy.Subscriber('/camera/depth/camera_info', CameraInfo, self.depth_camera_data, queue_size=1) rospy.Subscriber("/camera/depth/image", Image, self.depth_callback, queue_size=1) rospy.Subscriber('/crazyflie/state', String, self._cf_state_callback, queue_size=1) rospy.Subscriber('/crazyflie/cmd_vel', Twist, self._cf_cmd_vel_callback, queue_size=1) self.rate.sleep()
def run_demo(args): ie = IECore() detector_person = Detector(ie, path_to_model_xml=args.model_od, device=args.device, label_class=args.person_label) single_human_pose_estimator = HumanPoseEstimator(ie, path_to_model_xml=args.model_hpe, device=args.device) if args.input != '': img = cv2.imread(args.input[0], cv2.IMREAD_COLOR) frames_reader, delay = (VideoReader(args.input), 1) if img is None else (ImageReader(args.input), 0) else: raise ValueError('--input has to be set') presenter = monitors.Presenter(args.utilization_monitors, 25) for frame in frames_reader: bboxes = detector_person.detect(frame) human_poses = [single_human_pose_estimator.estimate(frame, bbox) for bbox in bboxes] presenter.drawGraphs(frame) colors = [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0), (255, 0, 0), (0, 255, 0)] for pose, bbox in zip(human_poses, bboxes): cv2.rectangle(frame, (bbox[0], bbox[1]), (bbox[0] + bbox[2], bbox[1] + bbox[3]), (255, 0, 0), 2) for id_kpt, kpt in enumerate(pose): cv2.circle(frame, (int(kpt[0]), int(kpt[1])), 3, colors[id_kpt], -1) cv2.putText(frame, 'summary: {:.1f} FPS (estimation: {:.1f} FPS / detection: {:.1f} FPS)'.format( float(1 / (detector_person.infer_time + single_human_pose_estimator.infer_time * len(human_poses))), float(1 / single_human_pose_estimator.infer_time), float(1 / detector_person.infer_time)), (5, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 200)) if args.no_show: continue cv2.imshow('Human Pose Estimation Demo', frame) key = cv2.waitKey(delay) if key == 27: return presenter.handleKey(key) print(presenter.reportMeans())
def __init__(self, parent=None): super().__init__() self.detector = Detector() # self.height self.width # 定义部件 self.menubar = None self.file_menu = None self.pic_action = None self.pic_label = None self.output_label = None self.prev_button = None self.next_button = None self.detect_button = None self.slider = None # 图片显示 self.chosen_pics = ["image.png"] self.cur_index = 0 # 初始化 self.init_ui()
def main(): dir_path = os.path.dirname(os.path.realpath(__file__)) lines = "*门冬胰岛素 300u×1.000 Sig.5-5-5u 三餐前 qd" lines = lines.lower() f_output = open(dir_path + r'\results\med_prescription_parser.json', 'w', errors='ignore', encoding='utf-8') det = Detector() try: prescs_lines = det.detector(lines) for line in prescs_lines: print(line) preparser = PrescParser() lines_res = preparser.parse(line) f_output.write(JSONObjectEncoder().to_json(lines_res)) f_output.write('\n') except exceptions.NoPrescException: print(lines) finally: f_output.close()
def __init__(self, cam_address, cam_user, cam_pass, detector_options = {}): self.detector = Detector(**detector_options) self.cam_address = cam_address self.cam_user = cam_user self.cam_pass = cam_pass self.byts = bytes() try: cv2.namedWindow(self.detector.winName, cv2.WINDOW_AUTOSIZE) except AttributeError, e: pass
def main(argv=None): # pylint: disable=unused-argument assert args.detect or args.segment, "Either detect or segment should be True" assert args.ckpt > 0, "Specify the number of checkpoint" net = ResNet(config=net_config, depth=50, training=False) loader = Loader(osp.join(EVAL_DIR, 'demodemo')) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)) as sess: detector = Detector(sess, net, loader, net_config, no_gt=args.no_seg_gt, folder=osp.join(loader.folder, 'output')) detector.restore_from_ckpt(args.ckpt) for name in loader.get_filenames(): image = loader.load_image(name) h, w = image.shape[:2] print('Processing {}'.format(name + loader.data_format)) detector.feed_forward(img=image, name=name, w=w, h=h, draw=True, seg_gt=None, gt_bboxes=None, gt_cats=None) print('Done')
def test_single_net(prefix, epoch, stage, attribute='landmark_pose'): model_path = '%s-%s' % (prefix, epoch) # load pnet model if stage == 12: detector = FcnDetector(P_Net, model_path) elif stage == 24: detector = Detector(R_Net, 24, 1, model_path) elif stage == 48: if 'landmark_pose' in attribute: detector = Detector(O_AUX_Net, 48, 1, model_path, aux_idx=3) #detector = Detector(JDAP_48Net_Landmark_Pose_Mean_Shape, 48, 1, model_path, aux_idx=3) elif 'landmark' in attribute: detector = Detector(JDAP_48Net_Landmark_Mean_Shape, 48, 1, model_path, aux_idx=1) #etector = Detector(JDAP_48Net_Landmark, 48, 1, model_path, aux_idx=1) elif 'pose' in attribute: detector = Detector(JDAP_48Net_Pose, 48, 1, model_path, aux_idx=2) else: detector = Detector(O_Net, 48, 1, model_path) return detector
def init_components(self, **kwargs): print('Setting up spectrometer') source = kwargs.get('source', 'blue') detector = kwargs.get('detector', 0) assert isinstance(source, str) assert isinstance(detector, int) self.source = Source(source) self.detector = Detector(detector)
def execute(self, message, draw=False): train = True if len(message) == 4 else False image = NNConnector.fileToImage(message[0]) gtKeyPoints = NNConnector.byteToKPs(message[1]) cvKeyPoints = NNConnector.byteToKPs(message[2]) test_pts = Detector(image, gtKeyPoints, cvKeyPoints, train) return np.array2string(test_pts(draw))
def recognizeCardNames(inputFolder, outputFolder, visualize): sym = SymspellMTGNames() lstm = LSTMClf() detector = Detector() allResults = [] imgPaths = findInputs(inputFolder) for imgPath in imgPaths: _dir, imgName = path.split(imgPath) img = cv2.imread(str(imgPath), cv2.IMREAD_GRAYSCALE) imgc = cv2.imread(str(imgPath)) img = squareResize(img) imgc = squareResize(imgc, grayScale=False) labels_boxes = detector.getNameBoxes(img, imgc) cards = [] boxes = [] for _label, box in labels_boxes: cropped = None try: cropped = crop(img, box) except: # Exception is thrown if the box has invalid size continue boxes.append(box) cards.append("") prediction = lstm.read_image( cropped.transpose()) # Transpose to column major format if len(prediction) > 0: # Add detection if there's a valid card name left after post processing predStr = prediction.lstrip() if len(predStr) > 0: corrected, _distance = sym.lookup(predStr) if corrected != None: cards[len(cards) - 1] = corrected allResults.append((imgName, imgc, cards, boxes)) return allResults
def main(): args = build_argparser().parse_args() ie = IECore() detector = Detector(ie, args.model, args.prob_threshold, args.device) img = cv2.imread(args.input[0], cv2.IMREAD_COLOR) frames_reader, delay = (VideoReader(args.input), 1) if img is None else (ImageReader(args.input), 0) if args.labels: with open(args.labels, 'r') as f: labels_map = [x.strip() for x in f] else: labels_map = None presenter = monitors.Presenter(args.utilization_monitors, 25) for frame in frames_reader: detections = detector.detect(frame) presenter.drawGraphs(frame) for det in detections: xmin, ymin, xmax, ymax = det[:4].astype(np.int) xmin = max(0, xmin) ymin = max(0, ymin) xmax = min(frame.shape[1], xmax) ymax = min(frame.shape[0], ymax) class_id = det[5] det_label = labels_map[int(class_id)] if labels_map else str(int(class_id)) color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 3, 255)) cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2) cv2.putText(frame, det_label + ' ' + str(round(det[4] * 100, 1)) + ' %', (xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1) cv2.putText(frame, 'summary: {:.1f} FPS'.format( 1.0 / detector.infer_time), (5, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 200)) if args.no_show: continue cv2.imshow('CenterNet Detection Demo', frame) key = cv2.waitKey(delay) if key == 27: return presenter.handleKey(key) print(presenter.reportMeans())
def run(): # Step 1: Initialization # 视频: video_helper.py # 检测: detector.py # 结果接收:acceptor.py # 参数配置: config.py # 总控: multiple_object_controller.py configs = Configs() detector = Detector(configs) acceptor = Acceptor(configs) video_helper = VideoHelper(configs) object_controller = MultipleObjectController(configs, video_helper) # step 2: 总体流程:main loop # A: 对物体,每帧检测,不要跟踪 (可以要平滑) # B: 对物体,要跟踪: a. 此帧有检测 (+observation correction) # b. 此帧无检测(只跟踪,pure predicton) cur_frame_counter = 0 detection_loop_counter = 0 while video_helper.not_finished(cur_frame_counter): # 0. get frame frame = video_helper.get_frame() # 1.1 每帧都检测 if not configs.NUM_JUMP_FRAMES: detects = detector.detect(frame) object_controller.update(detects) else: # 1.2 隔帧检测 # 1.2.1 此帧有检测 if detection_loop_counter % configs.NUM_JUMP_FRAMES == 0: detection_loop_counter = 0 detects = detector.detect(frame) object_controller.update(detects) # 核心 # 1.2.2 此帧无检测 else: object_controller.update_without_detection() # 核心 # deal with acceptor # ask acceptor do something cur_frame_counter += 1 detection_loop_counter += 1
def __init__(self): super(TFDetectNode, self).__init__() # init the node rospy.init_node('tf_detect', anonymous=False) # Get the parameters (model_name, num_of_classes, label_file, camera_namespace, video_name, num_workers) \ = self.get_parameters() # Create Detector self._detector = Detector(model_name, num_of_classes, label_file, num_workers) self._bridge = CvBridge() # Advertise the result of Object Detector self.pub_detections_data = rospy.Publisher('/detection/vision_objects', DetectedObjectArray, queue_size=1) # self.pub_detections_data = rospy.Publisher('/detections', DetectionArray, queue_size=1) # self.pub_detections_data = rospy.Publisher('/detections', DetectionArray, queue_size=1) # Advertise the result of Object Detector self.pub_detections_image = rospy.Publisher('/result_ripe', Image, queue_size=1) # self.pub_detections_image = rospy.Publisher( '/object_detection/detections_image', Image, queue_size=1) self.sub_rgb = rospy.Subscriber('/image_raw', Image, self.rgb_callback, queue_size=1, buff_size=2**24) # USE CAMERA TEST # USE CAMERA TEST # USE CAMERA TEST # self.sub_rgb = rospy.Subscriber('usb_cam/image_raw',Image, self.rgb_callback, queue_size=1, buff_size=2**24) # spin rospy.spin()
def main(): bulb = LED(environ.get('GPIO_LED')) water_gun = WaterGun(environ.get('GPIO_GUN')) with Detector(environ.get('PATH_TO_MODEL')) as detector: while detector.check(): if detector.is_detect(): bulb.blink(.5, .3) water_gun.fire(1) else: bulb.off()
def main(): seq = [] images = glob.glob(path + '*.tif') for i in images: image = cv2.imread(i, cv2.IMREAD_GRAYSCALE) seq.append(image) preprocessor = Preprocessor(seq) detector = Detector(preprocessor) matcher = Matcher(detector) drawer = Drawer(matcher, preprocessor) masks = preprocessor.get_masks() print('Generating all frames and cell states...') drawer.load() print('Successfully loaded all images') # Save all generated images and their masks to disk counter = 1 for g in drawer.get_gen_images(): annotated = cv2.imwrite(path + f'gen/{counter}.tif', g) mask = cv2.imwrite(path + f'gen/{counter}_mask.tif', masks[counter - 1]) if not annotated or not mask: print(f'Failed to save') counter += 1 print('Saved all images') # Now standby for user to issue commands for retrieval while True: string = input( 'Input a frame and cell ID (optional) separated by a space...\n') if string: string = string.split(' ') frame = int(string[0]) if len(string) > 1: try: id = int(string[1]) display_image = drawer.serve(frame, id) except ValueError: print(f'Not an integer') display_image = drawer.serve(frame) else: display_image = drawer.serve(frame) # plt.imshow(display_image) # plt.axis('off') # plt.show() # cv2.imshow('image',display_image) # cv2.waitKey(0) # cv2.destroyAllWindows() else: break
def __init__(self): Detector.__init__(self) self.bridge = CvBridge() self.light_classifier = TLClassifier() self.state = TrafficLight.UNKNOWN self.state_count = 0 self.dbw_enabled = False # the number of waypoints car brake but over the stopline self.brake_buffer = rospy.get_param('~brake_buffer', 5) rospy.Subscriber('/image_color', Image, self.image_cb, queue_size=1, buff_size=5760000) # subscribe the dbw_enabled to check car's position and orientation and set correct direction rospy.Subscriber('/vehicle/dbw_enabled', Bool, self.dbw_enabled_cb) self.upcoming_red_light_pub.publish(-1) rospy.spin()
def video(params=None): cap = cv2.VideoCapture(0) #cap.open("rtmp://rtmp01open.ys7.com/openlive/bd02a353615b4a12b1404f605218cb73.hd") K.set_learning_phase(0) det = Detector() while True: ret, img = cap.read() if not ret or len(img.shape) != 3: continue img = cv2.resize(img, (640, 480)) (height, width) = img.shape[:-1] det.predict(img) if img is not None: cv2.imshow("result", img) if cv2.waitKey(3) == 27: break
def video_thread(cls): detectorer = Detector() while Camera.running: is_night = Camera.is_night() Camera.frame = cls.get_video(is_night) if globals.OFFLINE_MODE: cv2.imshow('Depth', depth) detectorer.update_frame(Camera.frame) with Camera.read_lock: Camera.outputFrame = Camera.frame if globals.OFFLINE_MODE: cv2.imshow('Video', Camera.outputFrame) if Camera.running is False: log('CAMERA', 'Camera stopped.') return
def playbackTest(): """ Test code to assure tracker works with detector. """ def forwardImage(tuple): ind, frame = tuple detections = detector.getDetection(ind) image = cv2.applyColorMap(frame, cv2.COLORMAP_OCEAN) image = tracker.visualize(image, ind) figure.displayImage((ind, image)) def startDetector(): detector.initMOG() detector.computeAll() tracker.trackAll(detector.detections) playback_manager.play() app = QtWidgets.QApplication(sys.argv) main_window = QtWidgets.QMainWindow() playback_manager = PlaybackManager(app, main_window) detector = Detector(playback_manager) tracker = Tracker(detector) playback_manager.fps = 10 playback_manager.openTestFile() playback_manager.frame_available.connect(forwardImage) detector.mog_parameters.nof_bg_frames = 500 detector._show_detections = True playback_manager.mapping_done.connect(startDetector) figure = TestFigure(playback_manager.togglePlay) main_window.setCentralWidget(figure) LogObject().print(detector.parameters) LogObject().print(detector.parameters.mog_parameters) LogObject().print(tracker.parameters) main_window.show() sys.exit(app.exec_())
def main(args): '''通过PNet或RNet生成下一个网络的输入''' size = args.input_size batch_size = config.batches min_face_size = config.min_face stride = config.stride thresh = config.thresh scale_factor = config.scale_factor #模型地址 model_path = ['model/PNet/', 'model/RNet/', 'model/ONet'] if size == 12: net = 'PNet' save_size = 24 elif size == 24: net = 'RNet' save_size = 48 #图片数据地址 base_dir = 'data/WIDER_train/' #处理后的图片存放地址 data_dir = 'data/%d' % (save_size) neg_dir = os.path.join(data_dir, 'negative') pos_dir = os.path.join(data_dir, 'positive') part_dir = os.path.join(data_dir, 'part') for dir_path in [neg_dir, pos_dir, part_dir]: if not os.path.exists(dir_path): os.makedirs(dir_path) detectors = [None, None, None] PNet = FcnDetector(P_Net, model_path[0]) detectors[0] = PNet if net == 'RNet': RNet = Detector(R_Net, 24, batch_size[1], model_path[1]) detectors[1] = RNet filename = 'data/wider_face_train_celeba.txt' # 读取文件的image和box对应函数在utils中 data = read_anno(base_dir, filename) mtcnn_detector = MtcnnDetector(detectors, min_face_size=min_face_size, stride=stride, threshold=thresh) # save_path = data_dir # save_file = os.path.join(save_path, 'detections.pkl') # if not os.path.exists(save_file): # 将data制作成迭代器 print('载入数据') test_data = TestLoader(data['images']) detectors, _ = mtcnn_detector.detect_face(test_data) print('完成识别') # with open(save_file, 'wb') as f: # pickle.dump(detectors, f, 1) print('开始生成图像') save_hard_example(save_size, data, neg_dir, pos_dir, part_dir, detectors)
class Processor: def __init__(self, config: Dict[str, str]): if not 'detector_model' in config: print_err('Error: not found "detector_model" in config') raise ValueError self.detector = Detector(config['detector_model']) self.registry = None if 'chrome_web_driver' in config: self.registry = RegistryRequester( selenium_driver_path=config['chrome_web_driver']) else: self.registry = RegistryRequester() def __call__(self, image: Image, north: float, south: float, west: float, east: float): buildings = self.detector.detect(image) bottom_pxl = image.size[1] - 1 geo_to_pxl_ratio = (north - south) / image.size[1] result = [] for building in buildings: x1, y1, x2, y2, theta = building # A little workaround with bottom pxl due to PIL's coordinate system starting at the top left corner. sx2, sy2 = rotate_point2d(x2, bottom_pxl - y2, -theta) square = abs( pxl_to_geo(sx2 - x1, geo_to_pxl_ratio) * (pxl_to_geo(sy2 - (bottom_pxl - y1), geo_to_pxl_ratio))) cx, cy = (sx2 - x1) / 2, (sy2 - (bottom_pxl - y1)) / 2 cx, cy = rotate_point2d(cx, cy, theta) lat, lon = south + pxl_to_geo( cy, geo_to_pxl_ratio), west + pxl_to_geo(cx, geo_to_pxl_ratio) info = self.registry(lat, lon) home_in_registry = self.registry.is_home(lat, lon) result.append({ 'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2, 'theta': theta, 'lat': lat, 'lon': lon, 'building_found_in_registry': home_in_registry, 'square': square, 'cad_no': info['Кадастровый номер'] }) return result
def __init__( self, model_def="/home/haitao/Project/tongji_sanitation_car/Yolo/config/yolov3-custom.cfg", load_path="/home/haitao/Project/tongji_sanitation_car/Yolo/parameters/yolov3_ckpt_base.pth" ): self.yolo = Detector(torch.device("cpu"), model_def, load_path, reg_threshold=0.9, cls_threshold=0.2, nms_threshold=0.2, image_size=416)
def __init__(self,device="cpu", mod_path=path+'/scripts/perception/det_2021-02-20_11-44-05-076696.pt'): self.image_pub = rospy.Publisher("/myresult", Image, queue_size=1) self.detect_pub = rospy.Publisher("/Sign", Sign, queue_size=1) #create network self.detector = Detector() #.to(device) #load weights self.model = utils.load_model(self.detector,mod_path,device) self.bridge = CvBridge() self.image_sub = rospy.Subscriber("/cf1/camera/image_raw", Image, self.callback, queue_size=1, buff_size=2**28) self.tf_buf = tf2_ros.Buffer() self.tf_lstn = tf2_ros.TransformListener(self.tf_buf) self.broadcaster = tf2_ros.TransformBroadcaster()
def __init__(self): """ Configuration """ # Camera settings self.FRAME_WIDTH = 341 self.FRAME_HEIGHT = 256 self.flip_camera = True # Mirror image self.camera = cv2.VideoCapture(1) # ...you can also use a test video for input #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov" #self.camera = cv2.VideoCapture(video) #self.skip_input(400) # Skip to an interesting part of the video if not self.camera.isOpened(): print "couldn't load webcam" return #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH) #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT) self.filters_dir = "filters/" # Filter settings in trackbar self.filters_file = "filters_default" # Load filter settings current_config = self.filters_dir + self.filters_file self.filters = Filters(current_config) # No actions will be triggered in test mode # (can be used to adjust settings at runtime) self.test_mode = False # Create a hand detector # In fact, this is a wrapper for many detectors # to increase detection confidence self.detector = Detector(self.filters.config) # Knowledge base for all detectors self.kb = KB() # Create gesture recognizer. # A gesture consists of a motion and a hand state. self.gesture = Gesture() # The action module executes keyboard and mouse commands self.action = Action() # Show output of detectors self.output = Output() self.run()
class Cropper(object): """Cropper""" def __init__(self): super(Cropper, self).__init__() self.detector = Detector() @staticmethod def _bounding_rect(faces): top, left = sys.maxint, sys.maxint bottom, right = -sys.maxint, -sys.maxint for (x, y, w, h) in faces: if x < left: left = x if x+w > right: right = x+w if y < top: top = y if y+h > bottom: bottom = y+h return top, left, bottom, right def crop(self, img, target_width, target_height): original_height, original_width = img.shape[:2] faces = self.detector.detect_faces(img) if len(faces) == 0: # no detected faces target_center_x = original_width / 2 target_center_y = original_height / 2 else: top, left, bottom, right = self._bounding_rect(faces) target_center_x = (left + right) / 2 target_center_y = (top + bottom) / 2 target_left = target_center_x - target_width / 2 target_right = target_left + target_width target_top = target_center_y - target_height / 2 target_bottom = target_top + target_height if target_top < 0: delta = abs(target_top) target_top += delta target_bottom += delta if target_bottom > original_height: target_bottom = original_height if target_left < 0: delta = abs(target_left) target_left += delta target_right += delta if target_right > original_width: target_right = original_width return img[target_top:target_bottom, target_left:target_right]
def __init__(self, parent=None): super(Window, self).__init__(parent) self.detector = Detector() self.mediaThread = MediaThread(self) sys.stdout = common.EmittingStream(textWritten=self.normalOutputWritten) self.debugSignal.connect(self.debugTable) self.currentFrame = None self.bgColor = QColor(255, 255, 255) self.bgPath = '' self.classifiersParameters = {} self.setupUI() self.populateUI() self.connectUI() self.initUI()
def __init__(self, camera_id=None, show_display=False, width=FRAME_WIDTH, height=FRAME_HEIGHT, extra_time=EXTRA_TIME, video_directory=VIDEO_DIR, video_prefix=VIDEO_PREFIX, do_compress=DO_COMPRESS): self.camera = Camera(camera_id, prop_set={width: width, height: height}) self.total_pixels = height * width self.detector = Detector() self.display = None if show_display: self.display = Display((width, height)) self.extra_time_delta = timedelta(seconds=extra_time) self.video_prefix = os.path.join(video_directory, video_prefix) self.do_compress = do_compress
def populateTree(self, node, parent): """Create a QTreeView node under 'parent'. """ item = QtGui.QStandardItem(node) h, s, v = Detector.getDefaultHSVColor(node) color = QColor() color.setHsvF(h, s, v) item.setIcon(self.getIcon(color)) # Unique hash for QStandardItem key = hash(item) while key in self.classifiersParameters: key += 1 item.setData(key) cp = ClassifierParameters(item.data(), node, node, color, self.SHAPE_RECT, self.FILL_OUTLINE) self.classifiersParameters[key] = cp parent.appendRow(item) return item
class Spectrometer(object): '''This class represents the whole spectrometer. It bundles the detector and source in one object. :params detector: the selected detector (0 - builtin, default) :type detector: int :params source: the selected light source ('blue' is default) :type source: str ''' def __init__(self, **kwargs): self.init_components(**kwargs) def init_components(self, **kwargs): print('Setting up spectrometer') source = kwargs.get('source', 'blue') detector = kwargs.get('detector', 0) assert isinstance(source, str) assert isinstance(detector, int) self.source = Source(source) self.detector = Detector(detector) def measure(self, num_frames, num_dropped_frames, kind, **kwargs): '''Executes a measurment. :params num_frames: number of captured frames :type num_frames: int :params num_dropped_frames: number of frames to drop before collecting spectrum frames :type num_dropped_frames: int :params kind: The type of measurment. Choices are: 'background', 'spectrum', 'stream' :type kind: str ''' if kind == 'spectrum': #self.source_on() self.detector.measure_spectrum(num_frames, num_dropped_frames, **kwargs) #self.source_off() elif kind == 'background': #self.source_on() self.detector.measure_background(num_frames, num_dropped_frames, **kwargs) #self.source_off() elif kind == 'stream': #self.source_on() self.detector.stream() #self.source_off() else: sys.exit('Measurment type unknow.')
class Tracker(object): """ This is the main program which gives a high-level view of all the running subsystems. It connects camera input with output in form of "actions" (such as keyboard shortcuts on the users behalf). This is done by locating a hand in an image and detecting features, like the number of fingers, and trying to match that data with a known gesture. """ def __init__(self): """ Configuration """ # Camera settings self.FRAME_WIDTH = 341 self.FRAME_HEIGHT = 256 self.flip_camera = True # Mirror image self.camera = cv2.VideoCapture(1) # ...you can also use a test video for input #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov" #self.camera = cv2.VideoCapture(video) #self.skip_input(400) # Skip to an interesting part of the video if not self.camera.isOpened(): print "couldn't load webcam" return #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH) #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT) self.filters_dir = "filters/" # Filter settings in trackbar self.filters_file = "filters_default" # Load filter settings current_config = self.filters_dir + self.filters_file self.filters = Filters(current_config) # No actions will be triggered in test mode # (can be used to adjust settings at runtime) self.test_mode = False # Create a hand detector # In fact, this is a wrapper for many detectors # to increase detection confidence self.detector = Detector(self.filters.config) # Knowledge base for all detectors self.kb = KB() # Create gesture recognizer. # A gesture consists of a motion and a hand state. self.gesture = Gesture() # The action module executes keyboard and mouse commands self.action = Action() # Show output of detectors self.output = Output() self.run() def run(self): """ In each step: Read the input image and keys, process it and react on it (e.g. with an action). """ while True: img = self.get_input() hand = self.process(img) ref = self.action.get_reference_point() self.output.show(img, hand, ref) def process(self, img): """ Process input """ # Run detection hand = self.detector.detect(img) # Store result in knowledge base self.kb.update(hand) if not self.test_mode: # Try to interprete as gesture self.interprete(hand) return hand def interprete(self, hand): """ Try to interprete the input as a gesture """ self.gesture.add_hand(hand) operation = self.gesture.detect_gesture() self.action.execute(operation) def get_input(self): """ Get input from camera and keyboard """ self.get_key() _, img = self.camera.read() img = cv2.resize(img, (self.FRAME_WIDTH, self.FRAME_HEIGHT)) if self.flip_camera: img = cv2.flip(img, 1) return img def get_key(self): """ Read keyboard input """ key = cv2.waitKey(self.filters.config["wait_between_frames"]) if key == ord('+'): # Reduce program speed self.filters.config["wait_between_frames"] += 500 if key == ord('-'): # Increase program speed if self.filters.config["wait_between_frames"] >= 500: self.filters.config["wait_between_frames"] -= 500 #if key == ord('s'): # Save config # self.filters.save() if key == ord('r'): # Reset all detectors self.detector.reset() self.action.reset() if key == ord('d'): # Make a screenshot self.output.make_screenshot() if key == ord('p') or key == ord(' '): # Pause cv2.waitKey() if key == ord('t'): # Test mode self.test_mode = not self.test_mode if key == ord('1'): self.output.toggle_estimate() if key == ord('2'): self.output.toggle_detectors() if key == ord('3'): self.output.toggle_skin() if key == ord('f'): self.toggle_filters() if key == 63235: # Right arrow self.skip_input(20) if key == 27 or key == ord('q'): # Abort program on ESC, q or space exit() def toggle_filters(self): """ Load the next filter settings """ self.filters_file = self.next_filters_file() current_config = self.filters_dir + self.filters_file self.filters.set_config(current_config) def next_filters_file(self): """ Get the next filter settings """ filters = listdir(self.filters_dir) for i, f in enumerate(filters): if f == self.filters_file: return filters[(i+1) % len(filters)] def skip_input(self, x=1): """ Skip to a different part of a video sequence. """ for i in range(0,x): self.camera.grab()
os.unlink(filename) # DETECTOR DETECTOR DETECTOR threads = {} for key in config['detectors']: cameraName = config['detectors'][key]['camera'] if cameraName not in config['cameras']: raise KeyError('Failed to find "{0}" in camera listing for detection'.format(cameraName)) camera = Camera.create(config, cameraName) detector = Detector.create(config, camera) threads['detector_'.format(cameraName)] = detector detector.FaceDetected += OnFaceDetection fps = config['detectors'][key]['fps'] area = (config['detectors'][key]['area.x'], config['detectors'][key]['area.y'], config['detectors'][key]['area.h'], config['detectors'][key]['area.w']) print 'Creating detector for {0}'.format(cameraName) thread = threading.Thread(target=detector.faces, args=(fps, area)) thread.daemon = True thread.start() for key in config['motion']: cameraName = config['motion'][key]['camera'] if cameraName not in config['cameras']:
def execute(inputfile, extractor_out, detector_out=None, sorter_out=None): detector = Detector(inputfile, outpath=detector_out) sorter = SlideSorter(sources.ListSource(detector.detect_slides()), outpath=sorter_out) extractor = ContentExtractor(sources.ListSource(sorter.sort()), output_dir=extractor_out) extractor.analyze()
weight_path = '../caffe_layers_value.pickle' model_path = '../models/caltech256/model-2' jpg_folder_path = "../img_test" imgPath = [join(jpg_folder_path, f) for f in listdir(jpg_folder_path) if isfile(join(jpg_folder_path, f))] # load the caltech model f = open(model_label_path,"rb") label_dict = pickle.load(f) n_labels = len(label_dict) batch_size = 1 images_tf = tf.placeholder( tf.float32, [None, 224, 224, 3], name="images") labels_tf = tf.placeholder( tf.int64, [None], name='labels') detector = Detector( weight_path, n_labels ) c1,c2,c3,c4,conv5, conv6, gap, output = detector.inference( images_tf ) classmap = detector.get_classmap( labels_tf, conv6 ) sess = tf.InteractiveSession() saver = tf.train.Saver() saver.restore( sess, model_path ) # Fast forward images & save them for idx,imgP in enumerate(imgPath): img = Image.open(imgP) img = img.resize([224,224]) img = np.array(img) img = img.reshape(1,224,224,3)
E-mail : [email protected] """ from config import TEST_IMG from matplotlib import image from matplotlib import pyplot import pylab from time import time from detector import Detector start_time = time() img = image.imread(TEST_IMG) if len(img.shape) == 3: imgSingleChannel = img[:,:, 1] else: imgSingleChannel = img det = Detector() rectangles = det.scanImgOverScale(imgSingleChannel) end_time = time() print "Number of rectangles: ", len(rectangles) print "Cost time: ", end_time - start_time det.showResult(img, rectangles)
def __init__(self): super(Cropper, self).__init__() self.detector = Detector()
class Watcher(object): def __init__(self, camera_id=None, show_display=False, width=FRAME_WIDTH, height=FRAME_HEIGHT, extra_time=EXTRA_TIME, video_directory=VIDEO_DIR, video_prefix=VIDEO_PREFIX, do_compress=DO_COMPRESS): self.camera = Camera(camera_id, prop_set={width: width, height: height}) self.total_pixels = height * width self.detector = Detector() self.display = None if show_display: self.display = Display((width, height)) self.extra_time_delta = timedelta(seconds=extra_time) self.video_prefix = os.path.join(video_directory, video_prefix) self.do_compress = do_compress def get_frame(self): """ Get a frame with the camera, transform to greyscale and convert to Numpy array. """ now = datetime.now() image = self.camera.getImage().toGray() return VideoFrame(image=image, timestamp=now) def main_loop(self): frame_pre = self.get_frame() frame = self.get_frame() frame_post = self.get_frame() video_buffer = [] record_until = datetime.now() while True: detect = self.detector.detect_motion(frame_pre, frame, frame_post) if detect['has_motion']: record_until = frame.timestamp + self.extra_time_delta if self.display: detect['difference_image'].save(self.display) if frame.timestamp < record_until: video_buffer.append(frame) else: if video_buffer: buffer_fname = self.save_video(video_buffer) if self.do_compress and buffer_fname: proc = Process(target=self.compress_video, args=(buffer_fname,)) proc.start() video_buffer = [] frame_pre = frame frame = frame_post frame_post = self.get_frame() def save_video(self, video_buffer): """Use avconv to process the video buffer.""" buffer_fname = None if not video_buffer: return None start = video_buffer[0].timestamp end = video_buffer[-1].timestamp delta = (end - start).seconds if delta: fps = len(video_buffer) / delta print len(video_buffer), "frames in", delta, "seconds:", fps timestamp = video_buffer[0].timestamp.isoformat() timestamp = timestamp[:timestamp.rfind('.')] buffer_fname = '%s%s.avi' % (self.video_prefix, timestamp) video_streamer = VideoStream(fps=fps, filename=buffer_fname, framefill=False) map(video_streamer.writeFrame, [frame.image for frame in video_buffer]) print "Saved video:", buffer_fname return buffer_fname def compress_video(self, input_fname): output_fname = input_fname + '.mp4' params = '-i %s -c:a copy -c:v libx264 -crf 23 -s:v 640x480 %s' % ( input_fname, output_fname) call('avconv ' + params, shell=True) os.remove(input_fname)
def main(): main_parser = argparse.ArgumentParser(prog="cosmicpi", description="CosmicPi acquisition process", add_help=False) main_parser.add_argument("--config", help="Path to configuration file", default="/etc/cosmicpi.yaml") args, remaining_argv = main_parser.parse_known_args() # Merge the default config with the configuration file config = load_config(args.config) # Parse the command line for overrides parser = argparse.ArgumentParser(parents=[main_parser]) parser.set_defaults(**config) parser.add_argument("-i", "--host", **arg("broker.host", "Message broker host")) parser.add_argument("-p", "--port", **arg("broker.port", "Message broker port", type=int)) parser.add_argument("-a", "--username", **arg("broker.username", "Message broker username")) parser.add_argument("-b", "--password", **arg("broker.password", "Message broker password")) parser.add_argument("-n", "--no-publish", **arg("broker.enabled", "Disable event publication")) parser.add_argument("-u", "--usb", **arg("usb.device", "USB device name")) parser.add_argument("-d", "--debug", **arg("debug", "Enable debug mode")) parser.add_argument("-o", "--log-config", **arg("logging.config", "Path to logging configuration")) parser.add_argument("-l", "--no-log", **arg("logging.enabled", "Disable file logging")) parser.add_argument("-v", "--no-vib", **arg("monitoring.vibration", "Disable vibration monitoring")) parser.add_argument("-w", "--no-weather", **arg("monitoring.weather", "Disable weather monitoring")) parser.add_argument("-c", "--no-cosmics", **arg("monitoring.cosmics", "Disable cosmic ray monitoring")) parser.add_argument("-k", "--patk", **arg("patok", "Server push notification token")) options = parser.parse_args() log_config = options.logging["config"] print ("INFO: using logging configuration from %s" % log_config) logging.config.fileConfig(log_config, disable_existing_loggers=False) console = logging.getLogger(__name__) if options.debug: print_config(options) try: publisher = EventPublisher(options) except: console.error("Exception: Can't connect to broker") sys.exit(1) try: usb = UsbHandler(options.usb['device'], 9600, 60) usb.open() except Exception as e: console.error("Exception: Can't open USB device: %s" % e) sys.exit(1) detector = Detector(usb, publisher, options) try: detector.start() command_handler = CommandHandler(detector, usb, options) command_handler.start() while True: time.sleep(1) except Exception as e: console.info("Exception: main: %s" % e) traceback.print_exc() finally: detector.stop() console.info("Quitting ...") time.sleep(1) usb.close() publisher.close() sys.exit(0)
#! /usr/bin/env python # Main near-duplicate detection "runner" # # Written by Parker Moore (pjm336) # http://www.parkermoore.de import operator, copy from detector import Detector if __name__ == "__main__": # run the program detector = Detector('./test') print "Checking for duplicates using NDD..." duplicates = detector.check_for_duplicates() if duplicates: print "Duplicates found (Jaccard coefficient > 0.5):" print duplicates print "Printing three nearest neighbors of the first 10 files..." filenames_of_first_ten = [detector.filename("file%02d.txt") % (f,) for f in xrange(10)] filenames_of_first_one_hundred = [detector.filename("file%02d.txt") % (f,) for f in xrange(100)] for index1, j in enumerate(filenames_of_first_ten): jaccard_coefficients = [0] * 100 for index2, d in enumerate(filenames_of_first_one_hundred): if index1 != index2: jaccard_coefficients[index2] = detector.index.get_jaccard(j, d) three_nearest = [] nearest_count = -1 jcos = copy.deepcopy(jaccard_coefficients) while len(three_nearest) < 3: index,coefficient = max(enumerate(jcos), key=operator.itemgetter(1))
trainset = pd.DataFrame({'image_path': image_paths_train}) testset = pd.DataFrame({'image_path': image_paths_test }) trainset['label_name'] = trainset['image_path'].map(lambda x: x.split('/')[-2]) testset['label_name'] = testset['image_path'].map(lambda x: x.split('/')[-2]) trainset['label'] = trainset['label_name'].map( label_dict ) testset['label'] = testset['label_name'].map( label_dict ) train_phase = tf.placeholder( tf.bool ) learning_rate = tf.placeholder( tf.float32, []) images_tf = tf.placeholder( tf.float32, [None, 224, 224, 3], name="images") labels_tf = tf.placeholder( tf.int64, [None], name='labels') detector = Detector(weight_path, n_labels) p1,p2,p3,p4,conv5, conv6, gap, output = detector.inference(images_tf) loss_tf = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits( output, labels_tf )) weights_only = filter( lambda x: x.name.endswith('W:0'), tf.trainable_variables() ) weight_decay = tf.reduce_sum(tf.pack([tf.nn.l2_loss(x) for x in weights_only])) * weight_decay_rate loss_tf += weight_decay sess = tf.InteractiveSession() saver = tf.train.Saver( max_to_keep=50 ) #optimizer = tf.train.RMSPropOptimizer( learning_rate ) optimizer = tf.train.MomentumOptimizer( learning_rate, momentum ) grads_and_vars = optimizer.compute_gradients( loss_tf ) grads_and_vars = [(tf.clip_by_value(gv[0], -5., 5.), gv[1]) for gv in grads_and_vars]
class Window(QWidget, WindowUI): SOURCE_FILE = 'File' SOURCE_CAMERA = 'Camera' DISPLAY_INPUT = 'Input' DISPLAY_PREPROCESSED = 'Pre-processed' SHAPE_RECT = 'Rectangle' SHAPE_ELLIPSE = 'Ellipse' FILL_NONE = 'None' FILL_OUTLINE = 'Outline' FILL_COLOR = 'Color' FILL_BLUR = 'Blur' FILL_IMAGE = 'Image' FILL_MASK = 'Mask' BG_INPUT = 'Input' BG_COLOR = 'Color' BG_TRANSPARENT = 'Transparent' BG_IMAGE = 'Image' __sourceModes = [SOURCE_FILE, SOURCE_CAMERA] __displayModes = [DISPLAY_INPUT, DISPLAY_PREPROCESSED] __shapeModes = [SHAPE_RECT, SHAPE_ELLIPSE] __fillModes = [FILL_NONE, FILL_OUTLINE, FILL_BLUR, FILL_IMAGE, FILL_MASK, FILL_COLOR] __bgModes = [BG_INPUT, BG_COLOR, BG_TRANSPARENT, BG_IMAGE] IMAGE_FILTERS = '*.jpg *.png *.jpeg *.bmp' VIDEO_FILTERS = '*.avi *.mp4 *.mov' MASK_PATH = 'other/mask.png' debugSignal = QtCore.pyqtSignal(object, int) def __init__(self, parent=None): super(Window, self).__init__(parent) self.detector = Detector() self.mediaThread = MediaThread(self) sys.stdout = common.EmittingStream(textWritten=self.normalOutputWritten) self.debugSignal.connect(self.debugTable) self.currentFrame = None self.bgColor = QColor(255, 255, 255) self.bgPath = '' self.classifiersParameters = {} self.setupUI() self.populateUI() self.connectUI() self.initUI() def __del__(self): sys.stdout = sys.__stdout__ def keyPressEvent(self, e): if e.key() == QtCore.Qt.Key_Escape: self.close() def populateUI(self): self.availableObjectsList.addItems(Detector.getDefaultAvailableObjects()) for sourceMode in self.__sourceModes: self.sourceCBox.addItem(sourceMode) for displayMode in self.__displayModes: self.displayCBox.addItem(displayMode) for shapeMode in self.__shapeModes: self.shapeCBox.addItem(shapeMode) for fillMode in self.__fillModes: self.fillCBox.addItem(fillMode) for bgMode in self.__bgModes: self.bgCBox.addItem(bgMode) model = QtGui.QStandardItemModel(self) func = lambda node, parent: self.populateTree(node, parent) Detector.getDefaultObjectsTree().map(model, func) self.objectsTree.setModel(model) def connectUI(self): self.hsplitter.splitterMoved.connect(self.splitterMoved) self.vsplitter.splitterMoved.connect(self.splitterMoved) self.showDetails.clicked[bool].connect(self.toggleDebugInfo) self.addButton.clicked.connect(self.addObject) self.removeButton.clicked.connect(self.removeObject) self.sourceCBox.currentIndexChanged.connect(self.togglePath) self.sourcePathButton.clicked.connect(self.loadMedia) self.playButton.clicked.connect(self.play) self.refreshButton.clicked.connect(self.refresh) self.nextFrameButton.clicked.connect(self.nextFrame) self.objectsTree.customSelectionChanged.connect(self.showClassifierParameters) self.colorPicker.clicked.connect(self.colorDialog) self.classifierName.textChanged.connect(self.updateClassifierParameters) self.scaleFactor.valueChanged.connect(self.updateScaleFactor) self.minNeighbors.valueChanged.connect(self.updateMinNeighbors) self.minWidth.valueChanged.connect(self.updateMinWidth) self.minHeight.valueChanged.connect(self.updateMinHeight) self.shapeCBox.currentIndexChanged.connect(self.updateShape) self.fillCBox.currentIndexChanged.connect(self.updateFill) self.autoNeighbors.clicked.connect(self.calcNeighbors) self.stabilize.stateChanged.connect(self.updateStabilize) self.tracking.stateChanged.connect(self.updateTracking) self.showName.stateChanged.connect(self.updateShowName) self.fillPath.clicked.connect(self.loadFillPath) self.bgColorPicker.clicked.connect(self.bgColorDialog) self.bgPathButton.clicked.connect(self.bgPathDialog) self.bgCBox.currentIndexChanged.connect(self.toggleBgParams) def initUI(self): self.showClassifierParameters(None, None) self.equalizeHist.setChecked(True) self.toggleFillPath() self.toggleBgParams(self.bgCBox.currentIndex()) common.setPickerColor(self.bgColor, self.bgColorPicker) self.togglePlayButton(False) ######################################################## # Utils def getIcon(self, color): """Returns a colored icon. """ pixmap = QPixmap(14, 14) pixmap.fill(color) return QIcon(pixmap) def populateTree(self, node, parent): """Create a QTreeView node under 'parent'. """ item = QtGui.QStandardItem(node) h, s, v = Detector.getDefaultHSVColor(node) color = QColor() color.setHsvF(h, s, v) item.setIcon(self.getIcon(color)) # Unique hash for QStandardItem key = hash(item) while key in self.classifiersParameters: key += 1 item.setData(key) cp = ClassifierParameters(item.data(), node, node, color, self.SHAPE_RECT, self.FILL_OUTLINE) self.classifiersParameters[key] = cp parent.appendRow(item) return item def getMask(self, pixmap, x, y, w, h, shape, overlay, bg=QtCore.Qt.transparent, fg=QtCore.Qt.black, progressive=False): """Create a shape mask with the same size of pixmap. """ mask = QPixmap(pixmap.width(), pixmap.height()) mask.fill(bg) path = QtGui.QPainterPath() if progressive: progressive = QPixmap(pixmap.width(), pixmap.height()) progressive.fill(QtCore.Qt.transparent) progressiveMask = QPixmap(self.MASK_PATH) progressiveMask = progressiveMask.scaled(w, h, QtCore.Qt.IgnoreAspectRatio) progressivePainter = QtGui.QPainter(progressive) progressivePainter.drawPixmap(x, y, progressiveMask) del progressivePainter fg = QtGui.QBrush(progressive) painter = QtGui.QPainter(mask) if shape == self.SHAPE_ELLIPSE: path.addEllipse(x, y, w, h) painter.fillPath(path, fg) elif shape == self.SHAPE_RECT: painter.fillRect(x, y, w, h, fg) painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceAtop) if overlay: painter.drawPixmap(0, 0, overlay) return mask def drawTracking(self, painter, tracking, scale): """Draw lines between each position in tracking list. """ if not tracking: return hashTable = {} # Group tracks by item hash for track in tracking: for rect, hash in track: x, y, w, h = common.scaleRect(rect, scale) x, y = x + w / 2, y + h / 2 if hash in hashTable: hashTable[hash].append((x, y)) else: hashTable[hash] = [(x, y)] # Draw for hash, points in hashTable.iteritems(): prev = None for point in points: if prev: x1, y1 = point x2, y2 = prev painter.drawLine(x1, y1, x2, y2) prev = point def drawBackground(self, pixmap): """Draw background in pixmap. """ w, h = pixmap.width(), pixmap.height() mode = self.__bgModes[self.bgCBox.currentIndex()] source = QPixmap(pixmap) painter = QtGui.QPainter(pixmap) if mode == self.BG_COLOR: painter.fillRect(0, 0, w, h, self.bgColor) if mode == self.BG_TRANSPARENT or mode == self.BG_IMAGE or mode == self.BG_INPUT: painter.drawPixmap(0, 0, common.checkerboard(pixmap.size())) if mode == self.BG_IMAGE and self.bgPath: bgPixmap = QPixmap(self.bgPath) if not bgPixmap.isNull(): bgPixmap = bgPixmap.scaled(w, h, QtCore.Qt.IgnoreAspectRatio) painter.drawPixmap(0, 0, bgPixmap) if mode == self.BG_INPUT: painter.drawPixmap(0, 0, source) def fillMask(self, pixmap, painter, roi, param, source): """Draw mask in roi. """ x, y, w, h = roi masked = self.getMask(pixmap, x, y, w, h, param.shape, source, progressive=True) painter.drawPixmap(0, 0, masked) def fillBlur(self, pixmap, painter, roi, param, source): """Draw blur in roi. """ x, y, w, h = roi blurred = self.getMask(pixmap, x, y, w, h, param.shape, common.blurPixmap(pixmap, 20)) painter.drawPixmap(0, 0, blurred) def fillImage(self, pixmap, painter, roi, param, source): """Draw image in roi. """ x, y, w, h = roi fillPixmap = QPixmap(param.fillPath) if not fillPixmap.isNull(): fillPixmap = fillPixmap.scaled(w, h, QtCore.Qt.IgnoreAspectRatio) mask = self.getMask(pixmap, x, y, w, h, param.shape, None, QtCore.Qt.white, QtCore.Qt.black) painter.setClipRegion(QtGui.QRegion(QtGui.QBitmap(mask))) painter.drawPixmap(x, y, fillPixmap) painter.setClipping(False) def fillColor(self, pixmap, painter, roi, param, source): """Draw color in roi. """ x, y, w, h = roi if param.shape == self.SHAPE_ELLIPSE: path = QtGui.QPainterPath() path.addEllipse(x, y, w, h) painter.fillPath(path, param.color) elif param.shape == self.SHAPE_RECT: painter.fillRect(x, y, w, h, param.color) def fillOutline(self, pixmap, painter, roi, param, source): """Draw outline in roi. """ x, y, w, h = roi drawFunc = painter.drawRect if param.shape == self.SHAPE_ELLIPSE: drawFunc = painter.drawEllipse drawFunc(x, y, w, h) def drawRects(self, source, rectsTree, scale): """Draw rectangles in 'rectsTree' on 'source'. """ pixmap = QPixmap(source) self.drawBackground(pixmap) def drawRect(node, parentHash): painter = QtGui.QPainter(pixmap) roi, param, tracking = node.data x, y, w, h = common.scaleRect(roi, scale) painter.setPen(param.color) funcTable = { self.FILL_MASK: self.fillMask, self.FILL_BLUR: self.fillBlur, self.FILL_IMAGE: self.fillImage, self.FILL_COLOR: self.fillColor, self.FILL_OUTLINE: self.fillOutline } for fill, func in funcTable.iteritems(): if param.fill == fill: func(pixmap, painter, (x, y, w, h), param, source) if param.tracking: self.drawTracking(painter, tracking, scale) if param.showName: painter.drawText(x, y, param.name) return param.hash h, w = pixmap.height(), pixmap.width() rectsTree.map(None, drawRect) painter = QtGui.QPainter(source) painter.drawPixmap(0, 0, pixmap) def debugTable(self, args, append=False): """Display debug info into table. """ rows = len(args) if not append: self.debugCursor = self.debugText.textCursor() format = QtGui.QTextTableFormat() constraints = [QtGui.QTextLength(QtGui.QTextLength.FixedLength, size) for arg, size in args] format.setColumnWidthConstraints(constraints) format.setBorder(0) format.setCellPadding(2) format.setCellSpacing(0) self.debugCursor.insertTable(1, rows, format) scroll = self.debugText.verticalScrollBar() for arg, size in args: if arg: self.debugCursor.insertText(arg) self.debugCursor.movePosition(QtGui.QTextCursor.NextCell) scroll.setSliderPosition(scroll.maximum()) def debugEmitter(self, args, append=False): """Debug signal to allow threaded debug infos. """ self.debugSignal.emit(args, append) def detect(self, img, autoNeighbors=False, autoNeighborsParam=None): """Detect objects in img. """ self.currentFrame = img item = None indexes = self.objectsTree.selectedIndexes() if autoNeighbors and indexes: item = self.objectsTree.model().itemFromIndex(indexes[0]) # Detect on full size image tree, extracted = common.getObjectsTree(self.objectsTree, self.classifiersParameters, indexes, item) equalizeHist = self.equalizeHist.isChecked() rectsTree = self.detector.detect(img, tree, equalizeHist, self.debugEmitter, extracted, autoNeighborsParam) return rectsTree def displayImage(self, img): """Display numpy 'img' in 'mediaLabel'. """ rectsTree = self.detect(img) displayMode = self.__displayModes[self.displayCBox.currentIndex()] if displayMode == self.DISPLAY_PREPROCESSED: img = self.detector.preprocessed pixmap = common.np2Qt(img) w = float(pixmap.width()) # Scale image pixmap = common.fitImageToScreen(pixmap) scaleFactor = pixmap.width() / w # Draw scaled rectangles self.drawRects(pixmap, rectsTree, scaleFactor) self.mediaLabel.setPixmap(pixmap) self.mediaLabel.setFixedSize(pixmap.size()) def displayMedia(self, path): """Load and display media. """ if self.mediaThread.isRunning(): self.mediaThread.stop() self.mediaThread.wait() sourceMode = self.__sourceModes[self.sourceCBox.currentIndex()] self.mediaThread.start() self.togglePlayButton(True) def getSourceMode(self): """Return the current source mode. """ return self.__sourceModes[self.sourceCBox.currentIndex()] def getCurrentClassifierParameters(self): """Return current classifier parameters. """ index = self.objectsTree.currentIndex() item = index.model().itemFromIndex(index) param = self.classifiersParameters[item.data()] return item, param def toggleFillPath(self): """Display fill path dialog button if needed. """ index = self.fillCBox.currentIndex() fillMode = self.__fillModes[index] if fillMode == self.FILL_IMAGE: self.fillPath.show() else: self.fillPath.hide() def togglePlayButton(self, play=True): """Switch between play and pause icons. """ if play is True: self.playButton.setIcon(QIcon('assets/pause.png')) else: self.playButton.setIcon(QIcon('assets/play.png')) ######################################################## # Signals handlers def normalOutputWritten(self, text): """Append text to debug infos. """ cursor = self.debugText.textCursor() cursor.movePosition(QtGui.QTextCursor.End) cursor.insertText(text) self.debugText.setTextCursor(cursor) QApplication.processEvents() def play(self): """Play current media. """ if self.mediaThread.isRunning(): self.mediaThread.stop() self.mediaThread.wait() else: self.displayMedia(self.sourcePath.text()) def refresh(self): """Refresh current media. """ if self.mediaThread.isRunning(): self.mediaThread.stop() self.mediaThread.clean() self.displayMedia(self.sourcePath.text()) def nextFrame(self): """Go to next frame of current media. """ self.mediaThread.setNextFrameMode(True) self.displayMedia(self.sourcePath.text()) def loadFillPath(self): """Display file dialog to choose fill image. """ filters = self.tr('Image (' + self.IMAGE_FILTERS + ')') path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'), '.', filters) if path: item, param = self.getCurrentClassifierParameters() param.fillPath = path def loadMedia(self): """Load image or video. """ filters = "" filters = self.tr('Image (' + self.IMAGE_FILTERS + self.VIDEO_FILTERS + ')') path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'), '.', filters) if path: self.sourcePath.setText(path) self.mediaThread.stop() self.mediaThread.clean() self.displayMedia(path) def togglePath(self, index): """Hide path for camera mode. """ if self.__sourceModes[index] == self.SOURCE_CAMERA: self.sourcePath.hide() self.sourcePathButton.hide() self.displayMedia(self.sourcePath.text()) else: self.sourcePath.show() self.sourcePathButton.show() def colorDialog(self): """Open color dialog to pick a color. """ color = QColorDialog.getColor() if color.isValid(): common.setPickerColor(color, self.colorPicker) self.updateClassifierParameters(color=color) def bgColorDialog(self): """Open color dialog to pick a color. """ color = QColorDialog.getColor() if color.isValid(): self.bgColor = color common.setPickerColor(color, self.bgColorPicker) def bgPathDialog(self): """Open file dialog to select background image. """ filters = self.tr('Image (' + self.IMAGE_FILTERS + ')') path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'), '.', filters) if path: self.bgPath = path def toggleBgParams(self, index): """Hide / Show color picker and button path for background. """ mode = self.__bgModes[index] if mode == self.BG_COLOR: self.bgColorPicker.show() else: self.bgColorPicker.hide() if mode == self.BG_IMAGE: self.bgPathButton.show() else: self.bgPathButton.hide() def calcNeighbors(self): """Automatically calculate minimum neighbors. """ running = False if self.mediaThread.isRunning(): running = True self.mediaThread.stop() self.mediaThread.wait() self.detect(self.currentFrame, autoNeighbors=True, autoNeighborsParam=self.autoNeighborsParam.value()) self.showClassifierParameters(None, None) if running: self.displayMedia(self.sourcePath.text()) else: self.displayImage(self.currentFrame) def updateClassifierParameters(self, name=None, color=None): """Update classifier parameters. """ item, param = self.getCurrentClassifierParameters() if name: item.setText(name) param.name = name if color: item.setIcon(self.getIcon(color)) param.color = color def updateStabilize(self, checked): """Update stabilize classifier parameter. """ running = False if self.mediaThread.isRunning(): running = True self.mediaThread.stop() self.mediaThread.wait() item, param = self.getCurrentClassifierParameters() param.stabilize = checked self.detect(self.currentFrame) if running: self.displayMedia(self.sourcePath.text()) else: self.displayImage(self.currentFrame) def updateTracking(self, checked): """Update tracking classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.tracking = checked def updateScaleFactor(self, value): """Update scale factor classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.scaleFactor = value def updateShape(self, index): """Update shape classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.shape = self.__shapeModes[index] def updateFill(self, index): """Update fill classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.fill = self.__fillModes[index] self.toggleFillPath() def updateShowName(self, checked): """Update show name classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.showName = checked def updateMinNeighbors(self, value): """Update min neighbors classifier parameter. """ item, param = self.getCurrentClassifierParameters() param.minNeighbors = value def updateMinWidth(self, value): """Update minimum width classifier parameter. """ item, param = self.getCurrentClassifierParameters() w, h = param.minSize param.minSize = (value, h) def updateMinHeight(self, value): """Update minimum height classifier parameter. """ item, param = self.getCurrentClassifierParameters() w, h = param.minSize param.minSize = (w, value) def showClassifierParameters(self, selected, deselected): """Show the selected classifier parameters. """ selectedCount = len(self.objectsTree.selectedIndexes()) if selectedCount == 1: self.displayBox.setEnabled(True) self.parametersBox.setEnabled(True) index = self.objectsTree.currentIndex() item = index.model().itemFromIndex(index) param = self.classifiersParameters[item.data()] self.classifierName.setText(param.name) common.setPickerColor(param.color, self.colorPicker) self.classifierType.setText('(' + param.classifier + ')') self.scaleFactor.setValue(param.scaleFactor) self.minNeighbors.setValue(param.minNeighbors) w, h = param.minSize self.minWidth.setValue(w) self.minHeight.setValue(h) self.shapeCBox.setCurrentIndex(self.__shapeModes.index(param.shape)) self.fillCBox.setCurrentIndex(self.__fillModes.index(param.fill)) self.stabilize.setChecked(param.stabilize) self.showName.setChecked(param.showName) self.tracking.setChecked(param.tracking) else: self.displayBox.setEnabled(False) self.parametersBox.setEnabled(False) def addObject(self): """Add object to detect. """ selected = self.availableObjectsList.selectedItems() for item in selected: row = (self.availableObjectsList.row(item) + 1) % self.availableObjectsList.count() self.availableObjectsList.setCurrentRow(row) node = item.text() self.populateTree(node, self.objectsTree.model()) def removeObject(self): """Remove object to detect. """ selected = self.objectsTree.selectedIndexes() while selected and selected[0].model(): index = selected[0] item = index.model().itemFromIndex(index) del self.classifiersParameters[item.data()] if item.parent(): index.model().removeRow(item.row(), item.parent().index()) else: index.model().removeRow(item.row()) selected = self.objectsTree.selectedIndexes() def splitterMoved(self, pos, index): """Avoid segfault when QListWidget has focus and is going to be collapsed. """ focusedWidget = QApplication.focusWidget() if focusedWidget: focusedWidget.clearFocus() def toggleDebugInfo(self, pressed): """Toggle debug infos widget. """ if pressed: self.debugText.show() self.showDetails.setText(self.tr('Details <<<')) else: self.debugText.hide() self.showDetails.setText(self.tr('Details >>>'))