def __init__(self, cfg=None):
super(ComputeNode, self).__init__(cfg)
cfg = self.config()
logger.info("ComputeNode[%s] proxying cameras %s",
self, cfg['cameras'])
for i in xrange(len(cfg['cameras'])):
cfg['cameras'][i]['index'] = i
self.cameras = [base.proxy(c) for c in cfg['cameras']]
self.frame_callbacks = []
self.stats_callbacks = []
self.frames = [None for _ in xrange(len(self.cameras))]
self.stats = None
# Setup callbacks
for (i, c) in enumerate(self.cameras):
callback = lambda im, index=i: self._receive_frame(im, index)
stats_callback = lambda stats, index=i: \
self._receive_stats(stats, index)
c.new_image.connect(callback)
c.new_stats.connect(stats_callback)
self.frame_callbacks.append(callback)
self.stats_callbacks.append(stats_callback)
logger.info("ComputeNode[%s] proxying montager %s",
self, cfg['montager'])
self.montager_node = base.proxy(cfg['montager'])
self.montager_node.new_session.connect(lambda d: self.new_session(d))
self.montager_node.new_tile.connect(lambda t: self._receive_tile(t))
self.coarse_montager = None
self.new_image = pizco.Signal(nargs=1)
self.new_stats = pizco.Signal(nargs=1)
self.new_tile = pizco.Signal(nargs=1)
self.new_coarse_montage = pizco.Signal(nargs=1)
self.mean_percentiles = None
def __init__(self, cfg=None):
super(PiCameraNode, self).__init__(cfg)
self.new_image = pizco.Signal(nargs=1)
self.state = 'disconnected'
self.streaming = False
self.cam = None
self.last_frame_time = time.time()
def __init__(self, node):
self.node = node
self._state = None
self._override = False
self._conditions = None
#self._errors = []
self._running = False
self._future = None
self.new_state = pizco.Signal(nargs=1)
def __init__(self, cfg=None):
super(MontagerNode, self).__init__(cfg)
cfg = self.config()
logger.info("MontagerNode[%s] proxying motion %s", self, cfg['motion'])
self.motion = base.proxy(cfg['motion'])
logger.info("MontagerNode[%s] proxying cameras %s", self,
cfg['cameras'])
for i in xrange(len(cfg['cameras'])):
cfg['cameras'][i]['index'] = i # to make this 0 based
self.config(cfg)
self.cameras = [base.proxy(c) for c in cfg['cameras']]
self.new_position = pizco.Signal(nargs=1)
self.position_callback = self.motion.new_position.connect(
lambda p: self.new_position.emit(p))
#self.tiles = []
self.new_tile = pizco.Signal(nargs=1)
self.new_session = pizco.Signal(nargs=1)
def __init__(self, cfg=None):
base.IONode.__init__(self, cfg)
cfg = self.config()
#
#logger.info("TapeNode[%s] proxying motion %s", self, cfg['motion'])
self.cmd = None
self._state = None
self._barcodes = []
self.new_state = pizco.Signal(nargs=1)
def __init__(self, cfg=None):
base.IONode.__init__(self, cfg)
self._locked = False # software lock to prevent movement
self._controller = None
# setup axes (only on creation)
self._axes = {}
for chn in ('x', 'y'):
if chn in cfg:
self._axes[chn] = cfg[chn]['axis']
self.new_position = pizco.Signal(nargs=1)
def __init__(self, cfg=None):
super(ControlNode, self).__init__(cfg)
cfg = self.config()
# proxy child nodes
logger.info("ControlNode[%s] proxying tapecamera %s", self,
cfg['tapecamera'])
self.tapecamera = base.proxy(cfg['tapecamera'])
logger.info("ControlNode[%s] proxying tape %s", self, cfg['tape'])
self.tape = base.proxy(cfg['tape'])
logger.info("ControlNode[%s] proxying motion %s", self, cfg['motion'])
self.motion = base.proxy(cfg['motion'])
logger.info("ControlNode[%s] proxying cameras %s", self,
cfg['cameras'])
# index is necessary for filename formatting
for i in xrange(len(cfg['cameras'])):
#cfg['cameras'][i]['index'] = i + 1 # to make this 1 based
cfg['cameras'][i]['index'] = i # to make this 0 based
self.cameras = [base.proxy(c) for c in cfg['cameras']]
logger.info("ControlNode[%s] proxying montager %s", self,
cfg['montager'])
if cfg['montager'].get('fake', False):
logger.info("ControlNode[%s] making fake montager", self)
self.montager = fakemontager.FakeMontager()
else:
self.montager = base.proxy(cfg['montager'])
logger.info("ControlNode[%s] proxying compute %s", self,
cfg['compute'])
self.compute = base.proxy(cfg['compute'])
logger.info("ControlNode[%s] proxying scope %s", self, cfg['scope'])
self.scope = base.proxy(cfg['scope'])
# store current frames
self.frame_stats = [None for _ in xrange(len(self.cameras))]
self.frame_stats_callbacks = []
for (i, c) in enumerate(self.cameras):
scbf = lambda stats, index=i: self._receive_frame_stats(
stats, index)
c.new_stats.connect(scbf)
self.frame_stats_callbacks.append(scbf)
self.new_position = pizco.Signal(nargs=1)
self.position_callback = self.motion.new_position.connect(
lambda p: self.new_position.emit(p))
# setup slot source
self.slot_source = slotreader.SlotSource(cfg['slots']['source'])
self._kill = False
# setup all log levels
if 'save' in cfg and 'log_level' in cfg['save']:
# change log level of all nodes
for n in (self.cameras + [
self.tape, self.tapecamera, self.scope, self.montager,
self.compute, self
]):
n.set_log_level(cfg['save']['log_level'])
def __init__(self, cfg=None):
base.IONode.__init__(self, cfg)
self.cam = None
self.streaming = False
cfg = self.config()
self.last_barcodes = None
self._beam_slot = None
self.new_image = pizco.Signal(nargs=1)
self.new_barcodes = pizco.Signal(nargs=1)
self.new_slot_image = pizco.Signal(nargs=1)
self.new_beam_slot = pizco.Signal(nargs=1)
self.last_frame_time = time.time()
self._frame_count = 0
self._save_next_frame = False
self._processing = False
self._bcf = None
self._imf = None
self._slot_list = None
self.t_slot = pizco.Signal(nargs=1)
self._build_reel()
def __init__(self, cfg=None):
crop, n_words = utils.lookup_image_dimensions(cfg)
cfg['crop'] = crop
cfg['n_words'] = n_words
base.IONode.__init__(self, cfg)
self.pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
self.new_image = pizco.Signal(nargs=1)
self.new_stats = pizco.Signal(nargs=1)
self.new_stats_future = None
self.buffers = None
self.camera = None
self.frame = None
self.norm = None
self.analysis = None
self.saver = None
self.stats = None
self.controller = None
self.meta = {} # non-grab meta
self.mean_percentiles = None
self._stream_cb = None
def __init__(self, cfg=None):
cfg = config.parser.parse(cfg)
if cfg is not None:
if not isinstance(cfg, dict):
raise TypeError("Config must be a dict not {}".format(
type(cfg)))
self._config = cfg
else:
self._config = {}
self.loop = None # will be replaced with server ioloop
self._server = None
self._log_handler = None
self.config_changed = pizco.Signal(nargs=1)
logger.info("%s[%s] created", type(self), self)
def __init__(self, cfg=None):
super(MyIONode, self).__init__(cfg)
self.mysignal1 = pizco.Signal(nargs=1)
self.mysignal2 = pizco.Signal(nargs=1)
self._update_cb = None
self.counter = 0
def __init__(self, cfg=None):
super(StatefulIONode, self).__init__(cfg)
self.statemachine = None
self.new_state = pizco.Signal(nargs=1)
self._state_cb = None
def __init__(self, cfg=None):
base.IONode.__init__(self, cfg)
self._scope = None
self.response_signal = pizco.Signal(nargs=1)
