def setUp(self): self.low_resolution = DATA_FOLDER / Path('calib_png_small') self.high_resolution = DATA_FOLDER / Path('calib_jpg_u') self.low_calib_C0 = Calibrate(self.low_resolution, 'C0') self.low_calib_C1 = Calibrate(self.low_resolution, 'C1') self.high_calib_C0 = Calibrate(self.high_resolution, 'C0') self.high_calib_C1 = Calibrate(self.high_resolution, 'C1')
def setUp(self): # TODO: write what needs to be instantiated for each test self.low_resolution = DATA_FOLDER / Path('calib_png_small') self.high_resolution = DATA_FOLDER / Path('calib_jpg_u') self.low_calib_C0 = Calibrate(self.low_resolution, 'C0') self.low_calib_C1 = Calibrate(self.low_resolution, 'C1') self.high_calib_C0 = Calibrate(self.high_resolution, 'C0') self.high_calib_C1 = Calibrate(self.high_resolution, 'C1') self.decoder = Decoder(testing=True)
def load(self, host="localhost", port=6499): print "Tuner.load " + str(port) # Calibrate page self.calibrate = Calibrate(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.calibrate.get_widget(), "Calibrate") # Preflight page self.preflight = Preflight(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.preflight.get_widget(), "Preflight") # Launch page self.launch = Launch(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.launch.get_widget(), "Launch") # Circle hold page self.circle = Circle(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.circle.get_widget(), "Circle") # Chirp page self.chirp = Chirp(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.chirp.get_widget(), "Chirp") # Land page self.land = Land(changefunc=self.onChange, host=host, port=port) self.tabs.addTab(self.land.get_widget(), "Land")
def calibrate(numcam, num_bots, tcp_ips, tcp_ports, buffer_size, cam_pairs): CAM_IDS = [x % 10 for x in tcp_ports] cams_to_be_calib = get_cam_to_be_calibrated(cam_pairs) print 'cams_to_be_calib', cams_to_be_calib trackers = {} for y, x in cams_to_be_calib.items(): print x, y idx = CAM_IDS.index(y) z = CamTracker(y, num_bots, tcp_ips[idx], tcp_ports[idx], buffer_size) trackers[y] = z for i in trackers.keys(): trackers[i].thread.start() print cam_pairs tfs = [] for i, j in cam_pairs: print "======>", i, j tf = {} tf['from_to'] = (i, j) id_i = int(i) id_j = int(j) print id_j, id_i calib_obj = Calibrate(trackers[id_i], trackers[id_j], 'somefilename') calib_obj.calibrate() try: tf['tf'] = calib_obj.tf except: continue print calib_obj.R tfs.append(tf) close_trackers(trackers) return tfs
def __init__(self): super().__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.exportButton.setDisabled(True) self.ui.surfaceButton.setDisabled(True) self.calibrator = Calibrate() self.ui.CPULabel.setText(str(multiprocessing.cpu_count())) self.ui.spinBox.setMaximum(multiprocessing.cpu_count()) self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor() self.ui.graphwidget.recon.vtkWidget = self.ui.vtkWidget self.ui.cvViewer.PosFound.connect(self.ui.graphwidget.drawScatter) self.ui.checkBox.stateChanged.connect(self.start_scanning) self.ui.surfaceButton.clicked.connect(self.ui.graphwidget.drawSurface) self.ui.calibrateButton.clicked.connect(self.calibrator.show) self.calibrator.ui.captureButton.clicked.connect( lambda: self.calibrator.run(self.ui.cvViewer.camera.img)) self.ui.refreshButton.clicked.connect(self.serial_refresh) self.ui.comboBox.currentIndexChanged['int'].connect( self.serialdata_refresh) self.ui.cvViewer.finder.finished.connect( lambda: self.ui.checkBox.setCheckState(Qt.Unchecked)) self.ui.cvViewer.finder.finished.connect( lambda: self.ui.surfaceButton.setDisabled(False)) self.ui.cvViewer.motion.motionProgress['int'].connect( self.ui.progressBar.setValue) self.ui.cvViewer.finder.foundProgress['int'].connect( self.ui.scanprogressBar.setValue) self.ui.graphwidget.recon.reconstruction_status.connect( self.ui.textEdit.append) self.ui.graphwidget.recon.reconstruction_done.connect(self.recon_done) self.ui.spinBox.valueChanged.connect(self.ui.cvViewer.finder.setnump) self.ui.exportButton.clicked.connect(self.ui.graphwidget.export)
def __init__(self): self.isBgCaptured = 0 # bool, whether the background captured # Camera self.camera = cv2.VideoCapture(0) self.camera.set(10, 200) self.handDetect = HandDetect() self.calibrate = Calibrate() self.demo = None
def calibrate(objname, filtercol): from calibrate import Calibrate calv = Calibrate(obj=objname, filtercol=filtercol) calv.resetframes() calv.getrefframes() for r in calv.ref: print r for ref in calv.ref: print 'reference:', ref calv.getframes(ref) calv.corrframes(ref)
def calibrate(objname): from calibrate import Calibrate calv = Calibrate(obj=objname+' %%', filtercol='V') calv.resetframes() calv.getrefframes() for r in calv.ref: print r for ref in calv.ref: print 'reference:', ref calv.getframes(ref) calv.corrframes(ref) calb = Calibrate(obj=objname+' %%', filtercol='B') calb.resetframes() calb.getrefframes() for r in calb.ref: print r for ref in calb.ref: print 'reference:', ref calb.getframes(ref) calb.corrframes(ref)
def on_compensate(self): if not self.monitor_running: self.status.showMessage("Please, connect sensor") return if not self.compensate: self.toolbar_buttons['collection'].setText('Stop') initial = float(self.data_view['heading'].text()) self.calibrate = Calibrate(initial) self.compensate = True self.status.showMessage('Start compensate', 1000) else: self.toolbar_buttons['collection'].setText('Collection') self.progress.setValue(0) self.maxdub = self.calibrate.compute() del self.calibrate self.compensate = False self.status.showMessage('Stop compensate', 1000)
def calibrate(self, device_params, pool, miner_name, algorithm, region, quick, overwrite, force): devices = Nvidia().get_nvidia_devices(1) if pool == 'nicehash' and region not in [ 'eu', 'usa', 'hk', 'jp', 'in', 'br' ]: Log().add('fatal', 'a valid region is required for nicehash') devices_to_calibrate = [] device_classes = [] for device_param in device_params.split(','): if device_param.isdigit(): if int(device_param) >= len(devices): Log().add('fatal', 'device %d not found' % (int(device_param))) else: devices_to_calibrate.append(devices[int(device_param)]) else: found = False for device in devices: if device.name == device_param: devices_to_calibrate.append(device) found = True elif (device_param == 'all' or device.dclass == device_param ) and device.dclass not in device_classes: devices_to_calibrate.append(device) device_classes.append(device.dclass) found = True if not found: Log().add('fatal', 'device %s not found' % (device_param)) log_dir = Config().get('logging.calibration_log_dir') if not log_dir: log_dir = "/var/log/minotaur" if miner_name == "all": miners = [] for miner_name in Config().get('miners').keys(): if Config().get('miners')[miner_name]['enable']: miners.append(eval("%s()" % (miner_name.title()))) else: if not miner_name in Config().get('miners').keys(): Log().add('fatal', 'miner %s is not configured' % (miner_name)) miners = [eval("%s()" % (miner_name.title()))] if len(miners) == 0: Log().add('fatal', "no miners available") if pool == 'all': pools = [] for pool_name in Config().get('pools').keys(): if Config().get('pools.%s.enable' % (pool_name)): pools.append(pool_name) elif pool not in Config().get('pools').keys(): Log().add('fatal', 'unknown pool: %s' % (pool)) else: pools = [pool] algorithms = {} for pool_name in pools: algorithms[pool_name] = {} for miner in miners: if not pool_name in Pools().pools.keys(): Log().add('fatal', 'pool %s is not enabled' % (pool_name)) pool = Pools().pools[pool_name] if miner.name not in pool.supported_miners: continue if algorithm == "all": algorithms[pool_name][ miner.name] = miner.supported_algorithms() else: algorithms[pool_name][miner.name] = [] for algo_param in algorithm.split(","): if algo_param == 'all': algorithms[pool_name][ miner.name] = miner.supported_algorithms() else: if algo_param[0] == '!': exclude_algo = algo_param[1:] if miner.name in algorithms.keys( ) and exclude_algo in algorithms[miner.name]: algorithms[pool_name][miner.name].remove( exclude_algo) else: if algo_param in miner.supported_algorithms(): algorithms[pool_name][miner.name].append( algo_param) print "" self.calibration_banner() print "" n = 0 for device in devices_to_calibrate: log_file = "%s/calibration_%d.log" % (log_dir, device.id) Log().set_log_file(log_file) for pool_name in algorithms.keys(): for miner in miners: if miner.name in algorithms[pool_name].keys(): for algorithm in algorithms[pool_name][miner.name]: n += 1 if algorithm in Config( ).get('algorithms.single') or algorithm in Config( ).get('algorithms.double'): Calibration().load() if not overwrite and Calibration().get( '%s.%s.%s' % (device.dclass, miner.name, algorithm)): device.log( 'info', 'not overwriting existing calibration data for miner %s algorithm %s (use --overwrite to override)' % (miner.name, algorithm)) else: Calibrate().start(device, pool_name, miner, algorithm, region, quick, force) else: Log().add( 'warning', 'algorithm %s is not in the config file - skipping' % (algorithm)) Log().add('info', 'nothing to do.')
bufferAvg < minValueFromCal ): # this gets the minimum 8-sensor average from the time that calibration was run minValueFromCal = bufferAvg # it sets the threshold that separates gestures from resting. else: if (calibrateFlag == 1): mode = CALIBRATING gesture = REST mode = controlLogic(mode, gesture, 0) if (mode == CALIBRATING): print("mode = CALIBRATING") fistCal = Calibrate() fistGrouping = fistCal.getMaxGrouping(fistCalData) piwiCal = Calibrate() piwiGrouping = piwiCal.getMaxGrouping(piwiCalData) piwoCal = Calibrate() piwoGrouping = piwoCal.getMaxGrouping(piwoCalData) minValueFromCalArray = [ minValueFromCal, minValueFromCal, minValueFromCal ] with open(CSVFILE, 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(fistGrouping)
def __init__(self, video_port=0, pitch=None, planner_callback=None): self.config = Config(self) while pitch is None: req_room = raw_input("Enter Pitch Room [{opts}]: ".format( opts="/".join(self.config.pitch_room.options))) pitch_no = self.config.pitch_room.getCode( req_room, unifier=lambda str: re.sub(r'\W+', '', str.upper())) if pitch_no is not None: pitch = pitch_no self.config.pitch_room.selected = pitch if pitch == 0: self.config.colours = colour_profiles['pitch_3d03'] elif pitch == 1: self.config.colours = colour_profiles['pitch_3d04'] self.cam = Camera(port=video_port, pitch=pitch, config=self.config) #print("Camera initialised") def print_function(x): info(x) if planner_callback is None: self.planner_callback = (lambda x: print_function(x)) else: self.planner_callback = planner_callback c = Calibrate(self.cam, self.config) self.world_latest = World() self.world_previous = None # c.run(True) print("Basic camera calibration complete") colours = c.calibrateColor(self.cam) all_colors = np.empty([10, 3], dtype=np.uint8) color_id = 0 if colours is not None: for colour, data in colours.iteritems(): if data is not None: for field in data: self.config.colours[colour][field] = np.uint8( data[field]) all_colors[color_id] = np.uint8(data[field]) color_id += 1 print("Colors recorded") np.save("color_calibrations", all_colors) else: print("Colors calibration skipped") all_colors = np.load("color_calibrations.npy") all_color_names = ['red', 'yellow', 'blue', 'green', 'pink'] for i in range(0, 5): self.config.colours[all_color_names[i]]['max'] = all_colors[i * 2] self.config.colours[all_color_names[i]]['min'] = all_colors[i * 2 + 1] # print all_color_names[i], all_colors[i*2+1], all_colors[i*2] self.config.addFilter("overlay", filters.filter_overlay, default=1) self.config.addFilter("grayscale", filters.filter_grayscale) self.config.addFilter("normalised", filters.filter_normalize) self.config.addFilter("red", partial(filters.filter_colour, "red")) self.config.addFilter("yellow", partial(filters.filter_colour, "yellow")) self.config.addFilter("blue", partial(filters.filter_colour, "blue")) self.config.addFilter("green", partial(filters.filter_colour, "green")) self.config.addFilter("pink", partial(filters.filter_colour, "pink")) self.config.addFilter("manual colour", partial(filters.filter_colour, None)) #print("Filters set up") #print("Initialising trackers") self.tracker_ball = DotTracker(0, 0, 'red', self.config, "ball") self.tracker_blue = DotTracker(0, 0, 'yellow', self.config, "robot") self.tracker_yellow = DotTracker(0, 0, 'blue', self.config, "robot") self.config.GUI() self.display()