class MicroscopeView(View):
""" Represents a view from a microscope and ways to alter it.
Basically, its "input" is a StreamTree and it can request stage and focus
move. It never computes the composited image from all the streams itself.
It's up to other objects (e.g., the canvas) to ask the StreamTree for its
latest image (the main goal of this scheme is to avoid computation when not
needed). Similarly, the thumbnail is never automatically recomputed, but
other objects can update it.
"""
def __init__(self,
name,
stage=None,
focus0=None,
focus1=None,
stream_classes=None):
"""
:param name (string): user-friendly name of the view
:param stage (Actuator): actuator with two axes: x and y
:param focus0 (Actuator): actuator with one axis: z. Can be None
:param focus1 (Actuator): actuator with one axis: z. Can be None
Focuses 0 and 1 are modified when changing focus respectively along
the X and Y axis.
:param stream_classes (None, or tuple of classes): all subclasses that the
streams in this view is allowed to show.
"""
super(MicroscopeView, self).__init__(name)
if stream_classes is None:
self.stream_classes = (Stream, )
else:
self.stream_classes = stream_classes
self._stage = stage
self._focus = [focus0, focus1]
# The real stage position, to be modified via moveStageToView()
# it's a direct access from the stage, so looks like a dict of axes
if stage:
self.stage_pos = stage.position
# stage.position.subscribe(self.onStagePos)
# the current center of the view, which might be different from
# the stage
# TODO: we might need to have it on the MicroscopeModel, if all the
# viewports must display the same location
pos = self.stage_pos.value
view_pos_init = (pos["x"], pos["y"])
else:
view_pos_init = (0, 0)
self.view_pos = model.ListVA(view_pos_init, unit="m")
# current density (meter per pixel, ~ scale/zoom level)
# 10µm/px => ~large view of the sample
self.mpp = FloatContinuous(10e-6, range=(10e-12, 1e-3), unit="m/px")
# How much one image is displayed on the other one. Value used by
# StreamTree
self.merge_ratio = FloatContinuous(0.3, range=[0, 1], unit="")
self.merge_ratio.subscribe(self._onMergeRatio)
# Streams to display (can be considered an implementation detail in most
# cases)
# Note: use addStream/removeStream for simple modifications
self.stream_tree = StreamTree(merge=self.merge_ratio.value)
# Only modify with this lock acquired:
# TODO: Is this the source of the intermittent locking of the GUI when
# Streams are active? If so, is there another/better way?
self._streams_lock = threading.Lock()
# TODO: list of annotations to display
self.show_crosshair = model.BooleanVA(True)
def get_focus(self, i):
return self._focus[i]
def get_focus_count(self):
""" Get the number of available focus actuators """
return len([a for a in self._focus if a])
def has_stage(self):
return self._stage is not None
def moveStageToView(self):
""" Move the stage to the current view_pos
:return (None or Future): a future (that allows to know when the move is finished)
Note: once the move is finished stage_pos will be updated (by the
back-end)
"""
if not self._stage:
return
# TODO: a way to know if it can do absolute move? => .capabilities!
# if hasattr(self.stage, "moveAbs"):
# # absolute
# move = {"x": pos[0], "y": pos[1]}
# self._stage.moveAbs(move)
# else:
view_pos = self.view_pos.value
# relative
prev_pos = self.stage_pos.value
move = {
"x": view_pos[0] - prev_pos["x"],
"y": view_pos[1] - prev_pos["y"]
}
if abs(move["x"]) < 1e-12 and abs(move["y"]) < 1e-12:
logging.debug("skipping move request of 0")
return
# Check it makes sense (=> not too big)
distance = math.sqrt(sum([v**2 for v in move.values()]))
if distance > MAX_SAFE_MOVE_DISTANCE:
logging.error(
"Cancelling request to move by %f m (because > %f m)",
distance, MAX_SAFE_MOVE_DISTANCE)
return
logging.debug("Sending move request of %s", move)
return self._stage.moveRel(move)
# def onStagePos(self, pos):
# # we want to recenter the viewports whenever the stage moves
# # Not sure whether that's really the right way to do it though...
# # TODO: avoid it to move the view when the user is dragging the view
# # => might require cleverness
# # self.view_pos = model.ListVA((pos["x"], pos["y"]), unit="m")
def getStreams(self):
"""
:return: [Stream] list of streams that are displayed in the view
Do not modify directly, use addStream(), and removeStream().
Note: use .stream_tree for getting the raw StreamTree
"""
return self.stream_tree.getStreams()
def addStream(self, stream):
"""
Add a stream to the view. It takes care of updating the StreamTree
according to the type of stream.
stream (acq.stream.Stream): stream to add
If the stream is already present, nothing happens
"""
# check if the stream is already present
if stream in self.stream_tree.getStreams():
return
if not isinstance(stream, self.stream_classes):
msg = "Adding incompatible stream '%s' to view '%s'. %s needed"
logging.warning(msg, stream.name.value, self.name.value,
self.stream_classes)
# Find out where the stream should go in the streamTree
# FIXME: manage sub-trees, with different merge operations
# For now we just add it to the list of streams, with the only merge
# operation possible
with self._streams_lock:
self.stream_tree.add_stream(stream)
# subscribe to the stream's image
if hasattr(stream, "image"):
stream.image.subscribe(self._onNewImage)
# if the stream already has an image, update now
if stream.image.value is not None:
self._onNewImage(stream.image.value)
else:
logging.debug("No image found for stream %s", type(stream))
def removeStream(self, stream):
"""
Remove a stream from the view. It takes care of updating the StreamTree.
stream (Stream): stream to remove
If the stream is not present, nothing happens
"""
# Stop listening to the stream changes
if hasattr(stream, "image"):
stream.image.unsubscribe(self._onNewImage)
with self._streams_lock:
# check if the stream is already removed
if not stream in self.stream_tree.getStreams():
return
# remove stream from the StreamTree()
# TODO handle more complex trees
self.stream_tree.remove_stream(stream)
# let everyone know that the view has changed
self.lastUpdate.value = time.time()
def _onNewImage(self, im):
"""
Called when one stream has its image updated
im (DataArray)
"""
# just let everyone know that the composited image has changed
self.lastUpdate.value = time.time()
def _onMergeRatio(self, ratio):
"""
Called when the merge ratio is modified
"""
# This actually modifies the root operator of the stream tree
# It has effect only if the operator can do something with the "merge"
# argument
with self._streams_lock:
self.stream_tree.kwargs["merge"] = ratio
# just let everyone that the composited image has changed
self.lastUpdate.value = time.time()
def is_compatible(self, stream_cls):
""" Check if the given stream class is compatible with this view.
"""
return issubclass(stream_cls, self.stream_classes)
class StreamView(View):
"""
An abstract class that is common for every view which display layers of
streams and might have also actuators such as a stage and a focus.
Basically, its "input" is a StreamTree and it can request stage and focus
move. It never computes the composited image from all the streams itself.
It's up to other objects (e.g., the canvas) to ask the StreamTree for its
latest image (the main goal of this scheme is to avoid computation when not
needed). Similarly, the thumbnail is never automatically recomputed, but
other objects can update it.
"""
def __init__(self, name, stage=None, focus=None, stream_classes=None):
"""
:param name (string): user-friendly name of the view
:param stage (Actuator): actuator with two axes: x and y
:param focus (Actuator): actuator with one axis: z. Can be None
:param stream_classes (None, or tuple of classes): all subclasses that the
streams in this view is allowed to show.
"""
super(StreamView, self).__init__(name)
if stream_classes is None:
self.stream_classes = (Stream, )
else:
self.stream_classes = stream_classes
self._stage = stage
# TODO: allow to have multiple focus, one per stream class
self.focus = focus
if focus is not None:
self._focus_queue = Queue.Queue()
self._focus_thread = threading.Thread(target=self._moveFocus,
name="Focus mover view %s" %
name)
# TODO: way to detect the view is not used and so we need to stop the thread? (cf __del__?)
self._focus_thread.daemon = True
self._focus_thread.start()
# The real stage position, to be modified via moveStageToView()
# it's a direct access from the stage, so looks like a dict of axes
if stage:
self.stage_pos = stage.position
# the current center of the view, which might be different from
# the stage
pos = self.stage_pos.value
view_pos_init = (pos["x"], pos["y"])
else:
view_pos_init = (0, 0)
self.view_pos = model.ListVA(view_pos_init, unit="m")
# current density (meter per pixel, ~ scale/zoom level)
# 1µm/px => ~large view of the sample (view width ~= 1000 px)
self.mpp = FloatContinuous(1e-6, range=(10e-12, 50e-6), unit="m/px")
# How much one image is displayed on the other one. Value used by
# StreamTree
self.merge_ratio = FloatContinuous(0.3, range=[0, 1], unit="")
self.merge_ratio.subscribe(self._onMergeRatio)
# Streams to display (can be considered an implementation detail in most
# cases)
# Note: use addStream/removeStream for simple modifications
self.stream_tree = StreamTree(merge=self.merge_ratio.value)
# Only modify with this lock acquired:
# TODO: Is this the source of the intermittent locking of the GUI when
# Streams are active? If so, is there another/better way?
self._streams_lock = threading.Lock()
# TODO: list of annotations to display
self.show_crosshair = model.BooleanVA(True)
def has_stage(self):
return self._stage is not None
def _moveFocus(self):
time_last_move = 0
axis = self.focus.axes["z"]
try:
rng = axis.range
except AttributeError:
rng = None
try:
while True:
# wait until there is something to do
shift = self._focus_queue.get()
pos = self.focus.position.value["z"]
# rate limit to 20 Hz
sleept = time_last_move + 0.05 - time.time()
if sleept > 0:
time.sleep(sleept)
# Add more moves if there are already more
try:
while True:
shift += self._focus_queue.get(block=False)
except Queue.Empty:
pass
logging.debug("Moving focus by %f μm", shift * 1e6)
# clip to the range
if rng:
new_pos = pos + shift
new_pos = max(rng[0], min(new_pos, rng[1]))
req_shift = shift
shift = new_pos - pos
if abs(shift - req_shift) > 1e-9:
logging.info(
"Restricting focus move to %f µm as it reached the end",
shift * 1e6)
f = self.focus.moveRel({"z": shift})
time_last_move = time.time()
# wait until it's finished so that we don't accumulate requests,
# but instead only do requests of size "big enough"
try:
f.result()
except Exception:
logging.info("Failed to apply focus move", exc_info=1)
except Exception:
logging.exception("Focus mover thread failed")
def moveFocusRel(self, shift):
# FIXME: "stop all axes" should also clear the queue
self._focus_queue.put(shift)
def moveStageToView(self):
""" Move the stage to the current view_pos
:return (None or Future): a future (that allows to know when the move is finished)
Note: once the move is finished stage_pos will be updated (by the
back-end)
"""
if not self._stage:
return
view_pos = self.view_pos.value
# TODO: Use the max FoV of the streams to determine what's a big
# distance (because on the overview cam a move can be much bigger than
# on a SEM image at high mag).
# relative
prev_pos = self.stage_pos.value
move = {
"x": view_pos[0] - prev_pos["x"],
"y": view_pos[1] - prev_pos["y"]
}
if abs(move["x"]) < 1e-12 and abs(move["y"]) < 1e-12:
logging.debug("skipping move request of 0")
return
# Check it makes sense (=> not too big)
distance = math.sqrt(sum([v**2 for v in move.values()]))
if distance > MAX_SAFE_MOVE_DISTANCE:
logging.error(
"Cancelling request to move by %f m (because > %f m)",
distance, MAX_SAFE_MOVE_DISTANCE)
return
logging.debug("Sending move request of %s", move)
return self._stage.moveRel(move)
def getStreams(self):
"""
:return: [Stream] list of streams that are displayed in the view
Do not modify directly, use addStream(), and removeStream().
Note: use .stream_tree for getting the raw StreamTree
"""
return self.stream_tree.getStreams()
def addStream(self, stream):
"""
Add a stream to the view. It takes care of updating the StreamTree
according to the type of stream.
stream (acq.stream.Stream): stream to add
If the stream is already present, nothing happens
"""
# check if the stream is already present
if stream in self.stream_tree.getStreams():
return
if not isinstance(stream, self.stream_classes):
msg = "Adding incompatible stream '%s' to view '%s'. %s needed"
logging.warning(msg, stream.name.value, self.name.value,
self.stream_classes)
# Find out where the stream should go in the streamTree
# FIXME: manage sub-trees, with different merge operations
# For now we just add it to the list of streams, with the only merge
# operation possible
with self._streams_lock:
self.stream_tree.add_stream(stream)
# subscribe to the stream's image
if hasattr(stream, "image"):
stream.image.subscribe(self._onNewImage)
# if the stream already has an image, update now
if stream.image.value is not None:
self._onNewImage(stream.image.value)
else:
logging.debug("No image found for stream %s", type(stream))
def removeStream(self, stream):
"""
Remove a stream from the view. It takes care of updating the StreamTree.
stream (Stream): stream to remove
If the stream is not present, nothing happens
"""
# Stop listening to the stream changes
if hasattr(stream, "image"):
stream.image.unsubscribe(self._onNewImage)
with self._streams_lock:
# check if the stream is already removed
if not stream in self.stream_tree.getStreams():
return
# remove stream from the StreamTree()
# TODO handle more complex trees
self.stream_tree.remove_stream(stream)
# let everyone know that the view has changed
self.lastUpdate.value = time.time()
def _onNewImage(self, im):
"""
Called when one stream has its image updated
im (DataArray)
"""
# just let everyone know that the composited image has changed
self.lastUpdate.value = time.time()
def _onMergeRatio(self, ratio):
"""
Called when the merge ratio is modified
"""
# This actually modifies the root operator of the stream tree
# It has effect only if the operator can do something with the "merge"
# argument
with self._streams_lock:
self.stream_tree.kwargs["merge"] = ratio
# just let everyone that the composited image has changed
self.lastUpdate.value = time.time()
def is_compatible(self, stream_cls):
""" Check if the given stream class is compatible with this view.
"""
return issubclass(stream_cls, self.stream_classes)
class MicroscopeView(View):
""" Represents a view from a microscope and ways to alter it.
Basically, its "input" is a StreamTree and it can request stage and focus
move. It never computes the composited image from all the streams itself.
It's up to other objects (e.g., the canvas) to ask the StreamTree for its
latest image (the main goal of this scheme is to avoid computation when not
needed). Similarly, the thumbnail is never automatically recomputed, but
other objects can update it.
"""
def __init__(self, name, stage=None,
focus0=None, focus1=None, stream_classes=None):
"""
:param name (string): user-friendly name of the view
:param stage (Actuator): actuator with two axes: x and y
:param focus0 (Actuator): actuator with one axis: z. Can be None
:param focus1 (Actuator): actuator with one axis: z. Can be None
Focuses 0 and 1 are modified when changing focus respectively along
the X and Y axis.
:param stream_classes (None, or tuple of classes): all subclasses that the
streams in this view is allowed to show.
"""
super(MicroscopeView, self).__init__(name)
if stream_classes is None:
self.stream_classes = (Stream,)
else:
self.stream_classes = stream_classes
self._stage = stage
self._focus = [focus0, focus1]
# The real stage position, to be modified via moveStageToView()
# it's a direct access from the stage, so looks like a dict of axes
if stage:
self.stage_pos = stage.position
# stage.position.subscribe(self.onStagePos)
# the current center of the view, which might be different from
# the stage
# TODO: we might need to have it on the MicroscopeModel, if all the
# viewports must display the same location
pos = self.stage_pos.value
view_pos_init = (pos["x"], pos["y"])
else:
view_pos_init = (0, 0)
self.view_pos = model.ListVA(view_pos_init, unit="m")
# current density (meter per pixel, ~ scale/zoom level)
# 10µm/px => ~large view of the sample
self.mpp = FloatContinuous(10e-6, range=(10e-12, 1e-3), unit="m/px")
# How much one image is displayed on the other one. Value used by
# StreamTree
self.merge_ratio = FloatContinuous(0.3, range=[0, 1], unit="")
self.merge_ratio.subscribe(self._onMergeRatio)
# Streams to display (can be considered an implementation detail in most
# cases)
# Note: use addStream/removeStream for simple modifications
self.stream_tree = StreamTree(merge=self.merge_ratio.value)
# Only modify with this lock acquired:
# TODO: Is this the source of the intermittent locking of the GUI when
# Streams are active? If so, is there another/better way?
self._streams_lock = threading.Lock()
# TODO: list of annotations to display
self.show_crosshair = model.BooleanVA(True)
def get_focus(self, i):
return self._focus[i]
def get_focus_count(self):
""" Get the number of available focus actuators """
return len([a for a in self._focus if a])
def has_stage(self):
return self._stage is not None
def moveStageToView(self):
""" Move the stage to the current view_pos
:return (None or Future): a future (that allows to know when the move is finished)
Note: once the move is finished stage_pos will be updated (by the
back-end)
"""
if not self._stage:
return
# TODO: a way to know if it can do absolute move? => .capabilities!
# if hasattr(self.stage, "moveAbs"):
# # absolute
# move = {"x": pos[0], "y": pos[1]}
# self._stage.moveAbs(move)
# else:
view_pos = self.view_pos.value
# relative
prev_pos = self.stage_pos.value
move = {
"x": view_pos[0] - prev_pos["x"],
"y": view_pos[1] - prev_pos["y"]
}
if abs(move["x"]) < 1e-12 and abs(move["y"]) < 1e-12:
logging.debug("skipping move request of 0")
return
# Check it makes sense (=> not too big)
distance = math.sqrt(sum([v ** 2 for v in move.values()]))
if distance > MAX_SAFE_MOVE_DISTANCE:
logging.error("Cancelling request to move by %f m (because > %f m)",
distance, MAX_SAFE_MOVE_DISTANCE)
return
logging.debug("Sending move request of %s", move)
return self._stage.moveRel(move)
# def onStagePos(self, pos):
# # we want to recenter the viewports whenever the stage moves
# # Not sure whether that's really the right way to do it though...
# # TODO: avoid it to move the view when the user is dragging the view
# # => might require cleverness
# # self.view_pos = model.ListVA((pos["x"], pos["y"]), unit="m")
def getStreams(self):
"""
:return: [Stream] list of streams that are displayed in the view
Do not modify directly, use addStream(), and removeStream().
Note: use .stream_tree for getting the raw StreamTree
"""
return self.stream_tree.getStreams()
def addStream(self, stream):
"""
Add a stream to the view. It takes care of updating the StreamTree
according to the type of stream.
stream (acq.stream.Stream): stream to add
If the stream is already present, nothing happens
"""
# check if the stream is already present
if stream in self.stream_tree.getStreams():
return
if not isinstance(stream, self.stream_classes):
msg = "Adding incompatible stream '%s' to view '%s'. %s needed"
logging.warning(msg,
stream.name.value,
self.name.value,
self.stream_classes)
# Find out where the stream should go in the streamTree
# FIXME: manage sub-trees, with different merge operations
# For now we just add it to the list of streams, with the only merge
# operation possible
with self._streams_lock:
self.stream_tree.add_stream(stream)
# subscribe to the stream's image
if hasattr(stream, "image"):
stream.image.subscribe(self._onNewImage)
# if the stream already has an image, update now
if stream.image.value is not None:
self._onNewImage(stream.image.value)
else:
logging.debug("No image found for stream %s", type(stream))
def removeStream(self, stream):
"""
Remove a stream from the view. It takes care of updating the StreamTree.
stream (Stream): stream to remove
If the stream is not present, nothing happens
"""
# Stop listening to the stream changes
if hasattr(stream, "image"):
stream.image.unsubscribe(self._onNewImage)
with self._streams_lock:
# check if the stream is already removed
if not stream in self.stream_tree.getStreams():
return
# remove stream from the StreamTree()
# TODO handle more complex trees
self.stream_tree.remove_stream(stream)
# let everyone know that the view has changed
self.lastUpdate.value = time.time()
def _onNewImage(self, im):
"""
Called when one stream has its image updated
im (DataArray)
"""
# just let everyone know that the composited image has changed
self.lastUpdate.value = time.time()
def _onMergeRatio(self, ratio):
"""
Called when the merge ratio is modified
"""
# This actually modifies the root operator of the stream tree
# It has effect only if the operator can do something with the "merge"
# argument
with self._streams_lock:
self.stream_tree.kwargs["merge"] = ratio
# just let everyone that the composited image has changed
self.lastUpdate.value = time.time()
def is_compatible(self, stream_cls):
""" Check if the given stream class is compatible with this view.
"""
return issubclass(stream_cls, self.stream_classes)
class StreamView(View):
"""
An abstract class that is common for every view which display layers of
streams and might have also actuators such as a stage and a focus.
Basically, its "input" is a StreamTree and it can request stage and focus
move. It never computes the composited image from all the streams itself.
It's up to other objects (e.g., the canvas) to ask the StreamTree for its
latest image (the main goal of this scheme is to avoid computation when not
needed). Similarly, the thumbnail is never automatically recomputed, but
other objects can update it.
"""
def __init__(self, name, stage=None, focus=None, stream_classes=None):
"""
:param name (string): user-friendly name of the view
:param stage (Actuator): actuator with two axes: x and y
:param focus (Actuator): actuator with one axis: z. Can be None
:param stream_classes (None, or tuple of classes): all subclasses that the
streams in this view is allowed to show.
"""
super(StreamView, self).__init__(name)
if stream_classes is None:
self.stream_classes = (Stream,)
else:
self.stream_classes = stream_classes
self._stage = stage
# TODO: allow to have multiple focus, one per stream class
self.focus = focus
if focus is not None:
self._focus_queue = Queue.Queue()
self._focus_thread = threading.Thread(target=self._moveFocus,
name="Focus mover view %s" % name)
# TODO: way to detect the view is not used and so we need to stop the thread? (cf __del__?)
self._focus_thread.daemon = True
self._focus_thread.start()
# The real stage position, to be modified via moveStageToView()
# it's a direct access from the stage, so looks like a dict of axes
if stage:
self.stage_pos = stage.position
# the current center of the view, which might be different from
# the stage
pos = self.stage_pos.value
view_pos_init = (pos["x"], pos["y"])
else:
view_pos_init = (0, 0)
self.view_pos = model.ListVA(view_pos_init, unit="m")
# current density (meter per pixel, ~ scale/zoom level)
# 1µm/px => ~large view of the sample (view width ~= 1000 px)
self.mpp = FloatContinuous(1e-6, range=(10e-12, 50e-6), unit="m/px")
# How much one image is displayed on the other one. Value used by
# StreamTree
self.merge_ratio = FloatContinuous(0.3, range=[0, 1], unit="")
self.merge_ratio.subscribe(self._onMergeRatio)
# Streams to display (can be considered an implementation detail in most
# cases)
# Note: use addStream/removeStream for simple modifications
self.stream_tree = StreamTree(merge=self.merge_ratio.value)
# Only modify with this lock acquired:
# TODO: Is this the source of the intermittent locking of the GUI when
# Streams are active? If so, is there another/better way?
self._streams_lock = threading.Lock()
# TODO: list of annotations to display
self.show_crosshair = model.BooleanVA(True)
def has_stage(self):
return self._stage is not None
def _moveFocus(self):
time_last_move = 0
axis = self.focus.axes["z"]
try:
rng = axis.range
except AttributeError:
rng = None
try:
while True:
# wait until there is something to do
shift = self._focus_queue.get()
pos = self.focus.position.value["z"]
# rate limit to 20 Hz
sleept = time_last_move + 0.05 - time.time()
if sleept > 0:
time.sleep(sleept)
# Add more moves if there are already more
try:
while True:
shift += self._focus_queue.get(block=False)
except Queue.Empty:
pass
logging.debug("Moving focus by %f μm", shift * 1e6)
# clip to the range
if rng:
new_pos = pos + shift
new_pos = max(rng[0], min(new_pos, rng[1]))
req_shift = shift
shift = new_pos - pos
if abs(shift - req_shift) > 1e-9:
logging.info("Restricting focus move to %f µm as it reached the end",
shift * 1e6)
f = self.focus.moveRel({"z": shift})
time_last_move = time.time()
# wait until it's finished so that we don't accumulate requests,
# but instead only do requests of size "big enough"
try:
f.result()
except Exception:
logging.info("Failed to apply focus move", exc_info=1)
except Exception:
logging.exception("Focus mover thread failed")
def moveFocusRel(self, shift):
# FIXME: "stop all axes" should also clear the queue
self._focus_queue.put(shift)
def moveStageToView(self):
""" Move the stage to the current view_pos
:return (None or Future): a future (that allows to know when the move is finished)
Note: once the move is finished stage_pos will be updated (by the
back-end)
"""
if not self._stage:
return
view_pos = self.view_pos.value
# TODO: Use the max FoV of the streams to determine what's a big
# distance (because on the overview cam a move can be much bigger than
# on a SEM image at high mag).
# relative
prev_pos = self.stage_pos.value
move = {
"x": view_pos[0] - prev_pos["x"],
"y": view_pos[1] - prev_pos["y"]
}
if abs(move["x"]) < 1e-12 and abs(move["y"]) < 1e-12:
logging.debug("skipping move request of 0")
return
# Check it makes sense (=> not too big)
distance = math.sqrt(sum([v ** 2 for v in move.values()]))
if distance > MAX_SAFE_MOVE_DISTANCE:
logging.error("Cancelling request to move by %f m (because > %f m)",
distance, MAX_SAFE_MOVE_DISTANCE)
return
logging.debug("Sending move request of %s", move)
return self._stage.moveRel(move)
def getStreams(self):
"""
:return: [Stream] list of streams that are displayed in the view
Do not modify directly, use addStream(), and removeStream().
Note: use .stream_tree for getting the raw StreamTree
"""
return self.stream_tree.getStreams()
def addStream(self, stream):
"""
Add a stream to the view. It takes care of updating the StreamTree
according to the type of stream.
stream (acq.stream.Stream): stream to add
If the stream is already present, nothing happens
"""
# check if the stream is already present
if stream in self.stream_tree.getStreams():
return
if not isinstance(stream, self.stream_classes):
msg = "Adding incompatible stream '%s' to view '%s'. %s needed"
logging.warning(msg,
stream.name.value,
self.name.value,
self.stream_classes)
# Find out where the stream should go in the streamTree
# FIXME: manage sub-trees, with different merge operations
# For now we just add it to the list of streams, with the only merge
# operation possible
with self._streams_lock:
self.stream_tree.add_stream(stream)
# subscribe to the stream's image
if hasattr(stream, "image"):
stream.image.subscribe(self._onNewImage)
# if the stream already has an image, update now
if stream.image.value is not None:
self._onNewImage(stream.image.value)
else:
logging.debug("No image found for stream %s", type(stream))
def removeStream(self, stream):
"""
Remove a stream from the view. It takes care of updating the StreamTree.
stream (Stream): stream to remove
If the stream is not present, nothing happens
"""
# Stop listening to the stream changes
if hasattr(stream, "image"):
stream.image.unsubscribe(self._onNewImage)
with self._streams_lock:
# check if the stream is already removed
if not stream in self.stream_tree.getStreams():
return
# remove stream from the StreamTree()
# TODO handle more complex trees
self.stream_tree.remove_stream(stream)
# let everyone know that the view has changed
self.lastUpdate.value = time.time()
def _onNewImage(self, im):
"""
Called when one stream has its image updated
im (DataArray)
"""
# just let everyone know that the composited image has changed
self.lastUpdate.value = time.time()
def _onMergeRatio(self, ratio):
"""
Called when the merge ratio is modified
"""
# This actually modifies the root operator of the stream tree
# It has effect only if the operator can do something with the "merge"
# argument
with self._streams_lock:
self.stream_tree.kwargs["merge"] = ratio
# just let everyone that the composited image has changed
self.lastUpdate.value = time.time()
def is_compatible(self, stream_cls):
""" Check if the given stream class is compatible with this view.
"""
return issubclass(stream_cls, self.stream_classes)