def dropEvent(self, event):
# Get filename(s)
filenames = []
for url in event.mimeData().urls():
filenames.append(str(url.toLocalFile()))
# Send message(s) with filenames.
for filename in sorted(filenames):
[file_type, error_text] = params.fileType(filename)
if (file_type == "parameters"):
self.xml_directory = os.path.dirname(filename)
self.guiMessage.emit(
halMessage.HalMessage(m_type="new parameters file",
data={"filename": filename}))
elif (file_type == "shutters"):
self.xml_directory = os.path.dirname(filename)
self.guiMessage.emit(
halMessage.HalMessage(m_type="new shutters file",
data={"filename": filename}))
else:
if error_text:
halMessageBox.halMessageBoxInfo("XML file parsing error " +
error_text + ".")
else:
halMessageBox.halMessageBoxInfo(
"File type not recognized.")
def getHalMessage(self):
if self.filming:
return halMessage.HalMessage(source = self,
m_type = "stop film request")
else:
return halMessage.HalMessage(source = self,
m_type = "start film request",
data = {"request" : filmRequest.FilmRequest()})
def handleToggleFilm(self):
if not self.waiting_for_film:
if self.filming:
self.sendMessage(halMessage.HalMessage(m_type = "stop film request"))
else:
self.sendMessage(halMessage.HalMessage(m_type = "start film request",
data = {"request" : filmRequest.FilmRequest()}))
self.waiting_for_film = True
def setLockout(self, state, acquisition_parameters = None):
self.locked_out = state
if acquisition_parameters is not None:
self.sendMessage(halMessage.HalMessage(m_type = "film lockout",
data = {"locked out" : self.locked_out,
"acquisition parameters" : acquisition_parameters}))
else:
self.sendMessage(halMessage.HalMessage(m_type = "film lockout",
data = {"locked out" : self.locked_out}))
def processMessage(self, message):
if message.isType("configure1"):
# Initial UI configuration.
self.view.setObjectiveText(getObjectiveName(self.parameters))
# Add view to HAL UI display.
self.sendMessage(halMessage.HalMessage(m_type = "add to ui",
data = self.configure_dict))
# Broadcast initial parameters.
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.parameters}))
# Broadcast initial pixel size.
self.sendPixelSize(getObjectivePixelSize(self.parameters))
elif message.isType("new parameters"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.parameters.copy()}))
# Update parameters.
p = message.getData()["parameters"].get(self.module_name)
if (self.parameters.get("objective") != p.get("objective")):
objective = p.get("objective")
self.parameters.setv("objective", objective)
self.view.setObjectiveText(getObjectiveName(self.parameters))
self.sendPixelSize(getObjectivePixelSize(self.parameters))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.parameters}))
elif message.isType("stop film"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.parameters}))
elif message.isType("tcp message"):
tcp_message = message.getData()["tcp message"]
if tcp_message.isType("Get Mosaic Settings"):
if not tcp_message.isTest():
i = 1
pname = "obj" + str(i)
while self.parameters.has(pname):
tcp_message.addResponse(pname, self.parameters.get(pname))
i += 1
pname = "obj" + str(i)
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"handled" : True}))
elif tcp_message.isType("Get Objective"):
if not tcp_message.isTest():
obj_data = self.parameters.get(self.parameters.get("objective"))
tcp_message.addResponse("objective", obj_data.split(",")[0])
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"handled" : True}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("focuslock"):
qpd_fn_name = message.getData(
)["properties"]["qpd functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": qpd_fn_name,
"extra data": "qpd_fn"
}))
elif message.sourceIs("stage"):
stage_fn_name = message.getData(
)["properties"]["stage functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": stage_fn_name,
"extra data": "stage_fn"
}))
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": "display",
"extra data":
"camera_frame_viewer_fn"
}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.bt_control.getParameters()}))
elif message.isType("film lockout"):
if message.getData()["locked out"]:
self.bt_control.startFilm()
else:
self.bt_control.stopFilm()
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={
"old parameters":
self.bt_control.getParameters().copy()
}))
self.bt_control.newParameters(p.get(self.module_name))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.bt_control.getParameters()}))
def processMessage(self, message):
if message.isType("change directory"):
self.view.setDirectory(message.getData()["directory"])
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Stage",
"item data": "stage"
}))
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={"name": self.stage_fn_name}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.view.getParameters()}))
self.sendMessage(
halMessage.HalMessage(m_type="configuration",
data={
"properties": {
"stage functionality name":
self.stage_fn_name
}
}))
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"old parameters": self.view.getParameters().copy()}))
self.view.newParameters(p.get(self.module_name))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.view.getParameters()}))
elif message.isType("show"):
if (message.getData()["show"] == "stage"):
self.view.show()
elif message.isType("start"):
if message.getData()["show_gui"]:
self.view.showIfVisible()
elif message.isType("stop film"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.view.getParameters()}))
def handleResponse(self, message, response):
if message.isType("get functionality"):
self.timing_functionality.connectCameraFunctionality(response.getData()["functionality"])
# Broadcast timing information for the film.
props = {"functionality" : self.timing_functionality}
self.sendMessage(halMessage.HalMessage(m_type = "configuration",
data = {"properties" : props}))
# Tell film.film that this module is ready to film.
self.sendMessage(halMessage.HalMessage(m_type = "ready to film"))
def stopCameras(self):
# Stop master cameras first.
self.sendMessage(halMessage.HalMessage(m_type = "stop camera",
data = {"master" : True}))
# Force sync.
self.sendMessage(halMessage.SyncMessage(self))
# Stop slave cameras last.
self.sendMessage(halMessage.HalMessage(m_type = "stop camera",
data = {"master" : False},
finalizer = self.handleStopCamera))
def configure1(self):
"""
Send messages with the UI elements to HAL.
"""
self.guiMessage.emit(halMessage.HalMessage(source = self,
m_type = "add to ui",
data = {"ui_parent" : "hal.cameraFrame",
"ui_widget" : self.frame_viewer}))
self.guiMessage.emit(halMessage.HalMessage(source = self,
m_type = "add to ui",
data = {"ui_order" : 2,
"ui_parent" : "hal.containerWidget",
"ui_widget" : self.params_viewer}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("feeds"):
cur_time_base = self.parameters.get("time_base")
self.parameters.getp("time_base").setAllowed(message.getData()["properties"]["feed names"])
self.parameters.setv("time_base", cur_time_base)
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.parameters}))
# Let film.film know that it needs to wait for us
# to get ready before starting the cameras.
self.sendMessage(halMessage.HalMessage(m_type = "wait for",
data = {"module names" : ["film"]}))
elif message.isType("new parameters"):
#
# FIXME: The problem is that we won't know the allowed set of feed names until
# feeds.feeds sends the 'configuration' message. Using the old allowed
# might cause a problem as the new time base might not exist in the
# old allowed. For now we are just setting allowed to be whatever the
# time_base parameter value is. Then at 'feed names' we check that
# that the parameter is valid. If it is not valid this will break HAL
# at an unexpected point, the error should have been detected in
# 'new parameters'. Also the editor won't work because the version of the
# parameter that it has only allows one value. Somehow we need to know
# the valid feed names at the new parameter stage..
#
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.parameters.copy()}))
p = message.getData()["parameters"].get(self.module_name)
self.setAllowed([p.get("time_base")])
self.parameters.setv("time_base", p.get("time_base"))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.parameters}))
elif message.isType("start film"):
self.timing_functionality = TimingFunctionality(time_base = self.parameters.get("time_base"))
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : self.timing_functionality.getTimeBase()}))
elif message.isType("stop film"):
self.timing_functionality.disconnectCameraFunctionality()
self.timing_functionality = None
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.parameters.copy()}))
def handleControlMessage(self, message):
"""
These are messages from the Bluetooth Control class.
"""
if (message[0] == "lock jump"):
if halMessage.isValidMessageName("lock jump"):
self.sendMessage(halMessage.HalMessage(m_type = "lock jump",
data = {"delta" : message[1]}))
elif (message[0] == "start film"):
self.sendMessage(halMessage.HalMessage(m_type = "start film request",
data = {"request" : filmRequest.FilmRequest()}))
elif (message[0] == "stop film"):
self.sendMessage(halMessage.HalMessage(m_type = "stop film request"))
def handleLiveModeChange(self, state):
if state:
self.startCameras()
else:
self.stopCameras()
self.sendMessage(halMessage.HalMessage(m_type = "live mode",
data = {"live mode" : state}))
def handleFeedChange(self, feed_name):
self.guiMessage.emit(
halMessage.HalMessage(m_type="get functionality",
data={
"name": feed_name,
"extra data": self.module_name
}))
def handleResponses(self, message):
#
# This handles the case that the requested parameters are already
# the current parameters.
#
# Check that this is a response to the 'set parameters' message.
if not message.isType("set parameters"):
return False
# Check if this a response to our action, or a response to some
# other message from the tcpControl class.
if (message != self.hal_message):
return False
# Check for singleton response.
responses = message.getResponses()
assert (len(responses) == 1)
# Check that the requested parameters were found.
found = responses[0].getData()["found"]
if not found:
self.tcp_message.setError(True, "Parameters '" + self.tcp_message.getData("parameters") + "' not found")
self.was_handled = True
return True
# If these are the current parameters, send a 'start film request', if
# they are not then 'settings.settings' will switch HAL to these parameters
# and we'll monitor for the completion of the parameter change.
if responses[0].getData()["current"]:
msg = halMessage.HalMessage(m_type = "start film request",
data = {"request" : self.film_request})
self.actionMessage.emit(msg)
return False
def newParameters(self, parameters):
"""
Calls channels newParameters method, then updates the size of
the dialog as appropriate to fit all of the channels.
"""
current_position = self.pos()
# A sanity check that settings.settings is not giving us bad parameters.
for attr in parameters.getAttrs():
assert (type(self.parameters.getp(attr)) == type(
parameters.getp(attr)))
self.parameters = parameters
for channel in self.channels:
channel.newParameters(self.parameters)
#
# If the number of buttons change, this can cause the dialog to jump
# so we need to keep track of it's current position and reset to
# that position.
#
self.adjustSize()
self.setFixedSize(self.width(), self.height())
self.move(current_position)
# Update shutters file by sending a message so that film.film also updates.
self.guiMessage.emit(
halMessage.HalMessage(
m_type="new shutters file",
data={"filename": self.parameters.get("shutters")}))
def startFilmingLevel2(self):
"""
Then once all the cameras are stopped configure the imagewriters
for all of the feeds, and send the 'start film' message, followed
by the 'start camera' message.
"""
self.film_state = "run"
#
# Check if we are going to overwrite existing files by checking
# if we are going to overwrite the movies .xml file.
#
filename = self.film_settings.getBasename() + ".xml"
if not self.film_settings.overwriteOk() and os.path.exists(filename):
raise halExceptions.HALException("Movie files exist and overwrite Ok is false " + filename)
# Create writers as needed for each feed.
self.writers = []
if self.film_settings.isSaved():
for camera in self.camera_functionalities:
if camera.getParameter("saved"):
self.writers.append(imagewriters.createFileWriter(camera, self.film_settings))
if (len(self.writers) == 0):
self.view.updateSize(0.0)
# Start filming.
self.waiting_on = copy.copy(self.wait_for)
self.sendMessage(halMessage.HalMessage(sync = True,
m_type = "start film",
data = {"film settings" : self.film_settings}))
def processMessage(self, message):
#
# This is the signal that the parameter change is
# complete and we can start filming.
#
if message.isType("changing parameters"):
if not message.getData()["changing"]:
msg = halMessage.HalMessage(
m_type="start film request",
data={"request": self.film_request})
self.actionMessage.emit(msg)
#
# The 'film lockout' message with data 'locked out' is the signal
# that the film is complete.
#
elif message.isType("film lockout"):
if not message.getData()["locked out"]:
acq_p = message.getData()["acquisition parameters"]
if acq_p.has("spot_counts"):
self.tcp_message.addResponse("found_spots",
acq_p.get("spot_counts"))
return True
return False
def startCameras(self):
# Start slave camera(s) first.
self.sendMessage(halMessage.HalMessage(m_type = "start camera",
data = {"master" : False}))
# Force sync.
#
# We need to make sure that the slave cameras have started before
# starting the master cameras or we'll have a race condition.
#
self.sendMessage(halMessage.SyncMessage(self))
# Start master camera(s) last.
self.sendMessage(halMessage.HalMessage(m_type = "start camera",
data = {"master" : True}))
def handleResponses(self, message):
# Check if this a response to our action, or a response to some
# other message from the tcpControl class.
if (message != self.hal_message):
return False
# Check for singleton response.
responses = message.getResponses()
assert (len(responses) == 1)
# Check that the requested parameters were found.
found = responses[0].getData()["found"]
if not found:
self.tcp_message.setError(
True, "Parameters '" + self.tcp_message.getData("parameters") +
"' not found")
self.was_handled = True
return True
self.parameters = responses[0].getData()["parameters"]
# Check if the parameters are initialized.
if not self.parameters.get("initialized", False):
msg = halMessage.HalMessage(
m_type="set parameters",
data={"index or name": self.tcp_message.getData("parameters")})
self.actionMessage.emit(msg)
return False
self.was_handled = True
return True
def handleNewParameters(self, parameters, is_edit):
"""
Sends the 'new parameters' message.
The updated parameters could be a modified form of the current parameters or
it could be a different set. We use the is_edit flag to record which of these
two it is.
"""
if self.locked_out:
raise halExceptions.HalException(
"parameter change attempted while locked out.")
# Disable the UI so the user can't change the parameters again while we
# are processing the current change.
self.view.enableUI(False)
self.setLockout(True)
# is_edit means we are sending a modified version of the current parameters.
self.sendMessage(
halMessage.HalMessage(m_type="new parameters",
data={
"parameters": parameters.copy(),
"is_edit": is_edit
}))
def newViewer(self, v_type, v_name):
#
# FIXME: If you create a viewer during a film it is not going to
# to be in filming mode, and you won't be able to change
# things like sync_max.
#
# First look for an existing viewer that is just hidden.
found_existing_viewer = False
for viewer in self.viewers:
if isinstance(viewer, v_type) and not viewer.isVisible():
viewer.show()
found_existing_viewer = True
# If none exists, create a viewer of the requested type.
if not found_existing_viewer:
viewer = v_type(
module_name=self.getNextViewerName(),
default_colortable=self.parameters.get("colortable"))
viewer.halDialogInit(self.qt_settings,
self.window_title + " " + v_name)
viewer.guiMessage.connect(self.handleGuiMessage)
if self.stage_functionality is not None:
viewer.setStageFunctionality(self.stage_functionality)
viewer.showViewer(self.show_gui)
self.viewers.append(viewer)
self.sendMessage(
halMessage.HalMessage(
m_type="get feed names",
data={"extra data": viewer.getViewerName()}))
def startFilm(self, message):
self.run_shutters = message.getData()["film settings"].runShutters()
# Sub-classes must provide a "ready to film" response when they
# are ready to film otherwise film.film will hang.
if not self.run_shutters:
self.sendMessage(halMessage.HalMessage(m_type="ready to film"))
def startFilm(self, film_settings):
# Open file to save the lock status at each frame.
if self.working:
if film_settings.isSaved():
# Only save images when in diagnostics mode and only for a QPDCameraFunctionality.
if self.diagnostics_mode and (self.qpd_functionality.getType()
== "camera"):
self.tiff_counter = 0
self.tiff_fp = tifffile.TiffWriter(
film_settings.getBasename() + "_qpd.tif", bigtiff=True)
self.offset_fp = open(film_settings.getBasename() + ".off",
"w")
headers = [
"frame", "offset", "power", "stage-z", "good-offset"
]
if self.tiff_fp is not None:
headers.append("tif-counter")
self.offset_fp.write(" ".join(headers) + "\n")
# Check for a waveform from a hardware timed lock mode that uses the DAQ.
waveform = self.lock_mode.getWaveform()
if waveform is not None:
self.controlMessage.emit(
halMessage.HalMessage(m_type="daq waveforms",
data={"waveforms": [waveform]}))
self.lock_mode.startFilm()
def filmTiming(self, message):
"""
Get ready for waveform output when we get the film timing message, which
includes the frames per second information that we need.
"""
if self.run_shutters:
# Get frames per second from the timing functionality. This is
# a property of the camera that drives the timing functionality.
fps = message.getData()["properties"]["functionality"].getFPS()
# Calculate frequency. This is set slightly higher than the camere
# frequency so that we are ready at the start of the next frame.
frequency = 1.01 * fps * float(self.oversampling)
# If oversampling is 1 then just trigger the ao_task
# and do_task directly off the camera fire pin.
if (self.oversampling == 1):
wv_clock = self.timing.get("camera_fire_pin")
else:
wv_clock = self.timing.get("counter_out")
# Setup the counter.
self.setupCounter(frequency)
# Setup analog waveforms.
self.setupAnalog(frequency, wv_clock)
# Setup digital waveforms.
self.setupDigital(frequency, wv_clock)
# Notify film.film that we are ready.
self.sendMessage(halMessage.HalMessage(m_type="ready to film"))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("stage"):
stage_fn_name = message.getData(
)["properties"]["stage functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": stage_fn_name,
"extra data": "stage_fn"
}))
elif message.isType("configure1"):
if halMessage.isValidMessageName("lock jump"):
self.can_jump = True
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.control.getParameters()}))
elif message.isType("film lockout"):
# This means that filming has started (True), or stopped (False).
self.filming = message.getData()["locked out"]
# HAL has responded so we can stop ignoring the film button.
self.waiting_for_film = False
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={
"old parameters": self.control.getParameters().copy()
}))
self.control.newParameters(p.get(self.module_name))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.control.getParameters()}))
elif message.isType("stop film"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.control.getParameters()}))
def handleSettings(self, boolean):
parameters_filename = QtWidgets.QFileDialog.getOpenFileName(
self, "New Settings", self.xml_directory, "*.xml")[0]
if parameters_filename:
self.xml_directory = os.path.dirname(parameters_filename)
self.guiMessage.emit(
halMessage.HalMessage(m_type="new parameters file",
data={"filename": parameters_filename}))
def handleEditParameters(self):
"""
Send the 'current parameters' message.
Once all the modules have responded with their current parameters
we will start the editor.
"""
self.sendMessage(halMessage.HalMessage(m_type="current parameters"))
def processMessage(self, message):
if message.isType("start"):
self.sendMessage(halMessage.HalMessage(m_type="tss1"))
self.sendMessage(halMessage.HalMessage(m_type="tss2"))
self.sendMessage(halMessage.HalMessage(m_type="tss3"))
elif message.isType("tss1"):
halModule.runWorkerTask(self, message, self.handleTSS1)
elif message.isType("tss2"):
halModule.runWorkerTask(self, message, self.handleTSS2)
elif message.isType("tss3"):
assert not ("tss2" in self.processed_messages)
print(">> Okay", self.processed_messages)
self.newMessage.emit(
halMessage.HalMessage(source=self, m_type="tests done"))
def handleShutters(self, boolean):
shutters_filename = QtWidgets.QFileDialog.getOpenFileName(
self, "New Shutter Sequence", self.xml_directory, "*.xml")[0]
if shutters_filename:
self.xml_directory = os.path.dirname(shutters_filename)
self.guiMessage.emit(
halMessage.HalMessage(m_type="new shutters file",
data={"filename": shutters_filename}))
