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()
