def test_collect_background(self):
instance_manager = get_test_pipeline_manager_with_real_cam()
instance_manager.background_manager = BackgroundImageManager(
self.background_folder)
pipeline_id = "test_pipeline"
number_of_images = 10
pipeline_config = PipelineConfig(
pipeline_id, parameters={"camera_name": "simulation"})
instance_manager.config_manager.save_pipeline_config(
pipeline_id, pipeline_config.get_configuration())
pipeline_stream_address = instance_manager.get_instance_stream(
pipeline_id)
pipeline_host, pipeline_port = get_host_port_from_stream_address(
pipeline_stream_address)
# Collect from the pipeline.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
data = stream.receive()
self.assertIsNotNone(data,
"This should really not happen anymore.")
camera_name = instance_manager.get_instance(
pipeline_id).get_info()["camera_name"]
background_id = instance_manager.collect_background(
camera_name, number_of_images)
self.assertTrue(background_id.startswith("simulation"),
"Background id not as expected.")
host, port = get_host_port_from_stream_address(
instance_manager.cam_server_client.get_instance_stream(
"simulation"))
# Collect from the camera.
with source(host=host, port=port, mode=SUB) as stream:
data = stream.receive()
self.assertIsNotNone(data,
"This should really not happen anymore.")
self.assertEqual(
instance_manager.background_manager.get_background(
background_id).shape, data.data.data["image"].value.shape,
"Background and image have to be of the same shape.")
self.assertEqual(
instance_manager.background_manager.get_background(
background_id).dtype, data.data.data["image"].value.dtype,
"Background and image have to be of the same dtype.")
instance_manager.stop_all_instances()
def test_manager(self):
#Creating instances from config
instance_id_1, instance_stream_1 = self.pipeline_client.create_instance_from_name(
"simulation_sp")
pipeline_host_1, pipeline_port_1 = get_host_port_from_stream_address(
instance_stream_1)
self.assertEqual(pipeline_port_1, 10123)
self.pipeline_client.stop_instance(instance_id_1)
instance_id_2, instance_stream_2 = self.pipeline_client.create_instance_from_name(
"simulation_sp")
pipeline_host_2, pipeline_port_2 = get_host_port_from_stream_address(
instance_stream_2)
self.assertEqual(pipeline_host_1, pipeline_host_2)
self.assertEqual(pipeline_port_1, pipeline_port_2)
def get_stream(self, timeout=config.ZMQ_RECEIVE_TIMEOUT, data_change_callback=None):
source_host, source_port = get_host_port_from_stream_address(self.bsread_stream_address)
self.bsread_source = Source(host=source_host, port=source_port, mode=PULL,
receive_timeout=timeout)
self.bsread_source.handler = Handler(data_change_callback)
return self.bsread_source
def collect_background(self, cam_server_client, camera_name, n_images):
stream_address = cam_server_client.get_instance_stream(camera_name)
try:
host, port = get_host_port_from_stream_address(stream_address)
accumulator_image = None
with (ipc_source(address=stream_address, mode=SUB)
if stream_address.startswith("ipc") else source(
host=host, port=port, mode=SUB)) as stream:
for _ in range(n_images):
data = stream.receive()
image = data.data.data["image"].value
accumulator_image = sum_images(image, accumulator_image)
background_prefix = camera_name
background_image = accumulator_image / n_images
# Convert image to uint16.
background_image = background_image.astype(dtype="uint16")
background_id = self.save_background(background_prefix,
background_image)
return background_id
except:
_logger.exception("Error while collecting background.")
raise
def test_get_simulated_camera(self):
from cam_server import CamClient
from cam_server.utils import get_host_port_from_stream_address
from bsread import source, SUB
# Change to match your camera server
server_address = "http://0.0.0.0:8888"
# Initialize the client.
camera_client = CamClient(server_address)
# Get stream address of simulation camera. Stream address in format tcp://hostname:port.
camera_stream_address = camera_client.get_instance_stream("simulation")
# Extract the stream hostname and port from the stream address.
camera_host, camera_port = get_host_port_from_stream_address(
camera_stream_address)
# Subscribe to the stream.
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
# Receive next message.
data = stream.receive()
image_width = data.data.data["width"].value
image_height = data.data.data["height"].value
image_bytes = data.data.data["image"].value
print("Image size: %d x %d" % (image_width, image_height))
print("Image data: %s" % image_bytes)
x_size, y_size = get_simulated_camera().get_geometry()
self.assertIsNotNone(data)
self.assertEqual(image_width, x_size)
self.assertIsNotNone(image_height, y_size)
def connect_to_stream():
global source
pars = get_parameters()
input_stream = pars.get("input_stream")
if input_stream:
bsread_address = input_stream
bsread_channels = None
else:
bsread_address = pars.get("bsread_address")
bsread_channels = pars.get("bsread_channels")
default_input_mode = "SUB"
conn_type = CONNECT
if pars.get("pipeline_type", "") in [
"fanin",
]:
conn_type = BIND
default_input_mode = "PULL"
bsread_mode = pars.get("input_mode", default_input_mode)
_logger.debug("Connecting to stream %s. %s" %
(str(bsread_address), str(bsread_channels)))
receive_timeout = int(
pars.get("receive_timeout", config.PIPELINE_RECEIVE_TIMEOUT))
dispatcher_url, dispatcher_verify_request, dispatcher_disable_compression = get_dispatcher_parameters(
pars)
if bsread_address:
bsread_host, bsread_port = get_host_port_from_stream_address(
bsread_address)
bsread_mode = SUB if bsread_mode == "SUB" else PULL
else:
bsread_host, bsread_port = None, 9999
bsread_mode = PULL if bsread_mode == "PULL" else SUB
if bsread_channels is not None:
if type(bsread_channels) != list:
bsread_channels = json.loads(bsread_channels)
if len(bsread_channels) == 0:
bsread_channels = None
ret = bssource(
host=bsread_host,
conn_type=conn_type,
port=bsread_port,
mode=bsread_mode,
channels=bsread_channels,
receive_timeout=receive_timeout,
dispatcher_url=dispatcher_url,
dispatcher_verify_request=dispatcher_verify_request,
dispatcher_disable_compression=dispatcher_disable_compression)
if not is_camera_source():
source = ret.source
return ret
def create_sender(output_stream_port, stop_event):
global sender, pid_buffer, pid_buffer_size
sender = None
pars = get_parameters()
def no_client_action():
global sender
nonlocal pars
if pars["no_client_timeout"] > 0:
_logger.warning(
"No client connected to the pipeline stream for %d seconds. Closing instance. %s",
pars["no_client_timeout"], log_tag)
stop_event.set()
if sender:
if pars["mode"] == "PUSH" and pars["block"]:
_logger.warning(
"Killing the process: cannot stop gracefully if sender is blocking"
)
os._exit(0)
if pars["mode"] == "FILE":
file_name = pars["file"]
records = pars.get("records")
sender = WriterSender(output_file=file_name,
number_of_records=records
if records else UNDEFINED_NUMBER_OF_RECORDS,
layout=pars["layout"],
save_local_timestamps=pars["localtime"],
change=pars["change"],
attributes={})
else:
output_stream = pars.get("output_stream", None)
address = "tcp://*"
connect_type = BIND
if output_stream:
connect_type = CONNECT
address, output_stream_port = get_host_port_from_stream_address(
output_stream)
address = "tcp://" + address
sender = Sender(port=output_stream_port,
address=address,
conn_type=connect_type,
mode=PUSH if (pars["mode"] == "PUSH") else PUB,
queue_size=pars["queue_size"],
block=pars["block"],
data_header_compression=config.
CAMERA_BSREAD_DATA_HEADER_COMPRESSION)
sender.open(no_client_action=no_client_action,
no_client_timeout=pars["no_client_timeout"]
if pars["no_client_timeout"] > 0 else sys.maxsize)
init_sender(sender, pars)
if pars.get("pid_buffer", 0) > 1:
pid_buffer_size = pars.get("pid_buffer")
pid_buffer = {}
return sender
def get_running_camserver(self, camera, status):
servers = []
load = self.get_load(status)
loads = []
try:
instances = self.cam_server_client.get_server_info(
timeout=self.update_timeout if self.update_timeout else config.
DEFAULT_SERVER_INFO_TIMEOUT)["active_instances"]
host, port = get_host_port_from_stream_address(
instances[camera]["host"])
if not host.count(".") == 3: #If not IP, get only prefix
host = host.split(".")[0].lower()
local_names = ["127.0.0.1" "localhost"]
local_host_name = socket.gethostname()
if local_host_name:
local_names.append(local_host_name.split(".")[0].lower())
for i in range(len(self.server_pool)):
if load[i] < 1000:
try:
server_host, server_port = get_host_port_from_stream_address(
self.server_pool[i].get_address())
if not host.count(
".") == 3: # If not IP, get only prefix
server_host = server_host.split(
".")[0].lower() if server_host else None
if host == server_host:
servers.append(self.server_pool[i])
loads.append(load[i])
if (host in local_names) and (server_host
in local_names):
servers.append(self.server_pool[i])
loads.append(load[i])
except:
pass
except:
pass
if len(servers) > 0:
m = min(loads)
return servers[loads.index(m)]
return None
def get_stream(self):
self.verify_camera_online()
self._collect_camera_settings()
source_host, source_port = get_host_port_from_stream_address(self.bsread_stream_address)
self.bsread_source = Source(host=source_host, port=source_port, mode=PULL,
receive_timeout=config.ZMQ_RECEIVE_TIMEOUT)
return self.bsread_source
def get_images(screen, n_images, beamline='Aramis', dry_run=None):
print('Start get_images for screen %s, %i images, beamline %s' %
(screen, n_images, beamline))
meta_dict_1 = get_meta_data(screen)
positioner = pyscan.BsreadPositioner(n_messages=n_images)
settings = pyscan.scan_settings(settling_time=0.01,
measurement_interval=0.2,
n_measurements=1)
pipeline_client = PipelineClient("http://sf-daqsync-01:8889/")
cam_instance_name = str(screen) + "_sp1"
stream_address = pipeline_client.get_instance_stream(cam_instance_name)
stream_host, stream_port = get_host_port_from_stream_address(
stream_address)
# Configure bsread
pyscan.config.bs_default_host = stream_host
pyscan.config.bs_default_port = stream_port
logging.getLogger("mflow.mflow").setLevel(logging.ERROR)
readables = get_readables(beamline)
raw_output = pyscan.scan(positioner=positioner,
readables=readables,
settings=settings)
output = [[x] for x in raw_output]
result_dict = pyscan_result_to_dict(readables, output, scrap_bs=True)
for ax in ['x_axis', 'y_axis']:
arr = result_dict[ax] * 1e-6 # convert to m
if len(arr.shape) == 3:
result_dict[ax + '_m'] = arr[0, 0, :]
elif len(arr.shape) == 2:
result_dict[ax + '_m'] = arr[0, :]
else:
raise ValueError('Unexpected', len(arr.shape))
meta_dict_2 = get_meta_data(screen)
output_dict = {
'pyscan_result': result_dict,
'meta_data_begin': meta_dict_1,
'meta_data_end': meta_dict_2,
}
print('End get_images')
return output_dict
def create_source(camera_stream_address,
receive_timeout=config.PIPELINE_RECEIVE_TIMEOUT,
mode=SUB):
source_host, source_port = get_host_port_from_stream_address(
camera_stream_address)
if camera_stream_address.startswith("ipc"):
return IpcSource(address=camera_stream_address,
receive_timeout=receive_timeout,
mode=mode)
else:
return Source(host=source_host,
port=source_port,
receive_timeout=receive_timeout,
mode=mode)
def resolve_camera_source(cam_client, pars=None):
if pars is None:
pars = get_parameters()
source_mode = SUB
input_stream = pars.get("input_stream")
if input_stream:
camera_stream_address = input_stream
source_mode = PULL if pars.get("input_mode", "SUB") == "PULL" else SUB
else:
camera_stream_address = cam_client.get_instance_stream(
pars.get("camera_name"))
source_host, source_port = get_host_port_from_stream_address(
camera_stream_address)
return camera_stream_address, source_host, source_port, source_mode
def test_user_scripts(self):
script_name = "Test.py"
script_content = "print('Hello world')"
self.pipeline_client.set_user_script(script_name, script_content)
scripts = self.pipeline_client.get_user_scripts()
self.assertIn(script_name, scripts)
ret = self.pipeline_client.get_user_script(script_name)
self.assertEqual(ret, script_content)
filename = "temp/Test2.py"
with open(filename, "w") as data_file:
data_file.write(script_content)
self.pipeline_client.upload_user_script(filename)
os.remove(filename)
self.pipeline_client.download_user_script(filename)
with open(filename, "r") as data_file:
ret = data_file.read()
self.assertEqual(ret, script_content)
script_content = """
from cam_server.pipeline.data_processing import functions, processor
def process_image(image, pulse_id, timestamp, x_axis, y_axis, parameters, bsdata):
ret = processor.process_image(image, pulse_id, timestamp, x_axis, y_axis, parameters, bsdata)
ret["average_value"] = float(ret["intensity"]) / len(ret["x_axis"]) / len(ret["y_axis"])
return ret
"""
filename = "temp/Test.py"
with open(filename, "w") as data_file:
data_file.write(script_content)
instance_id, stream_address = self.pipeline_client.create_instance_from_config(
{"camera_name": "simulation"})
host, port = get_host_port_from_stream_address(stream_address)
with source(host=host, port=port, mode=SUB) as stream:
data = stream.receive()
self.assertIsNotNone(data,
"This should really not happen anymore.")
self.assertIsNotNone(data.data.data["width"].value)
self.assertIsNotNone(data.data.data["height"].value)
self.pipeline_client.set_function_script(instance_id, filename)
time.sleep(1.0)
with source(host=host, port=port, mode=SUB) as stream:
data = stream.receive()
print(data.data.data.keys())
self.assertIsNotNone(data.data.data["average_value"].value)
def test_named_buffered_pipeline(self):
instance_id, stream_address = self.pipeline_client.create_instance_from_name(
"simulation",
additional_config={
"buffer_size": 20,
"no_client_timeout": 60,
"mode": "PUSH",
"queue_size": 1
})
host, port = get_host_port_from_stream_address(stream_address)
time.sleep(2.0)
with source(host=host, port=port, mode=PULL) as stream:
for i in range(10):
data = stream.receive()
self.assertEqual(data.data.pulse_id, i + 1)
self.pipeline_client.stop_all_instances()
def test_create_pipeline_with_background(self):
from cam_server import PipelineClient
from cam_server.utils import get_host_port_from_stream_address
from bsread import source, SUB
# Change to match your pipeline server
server_address = "http://0.0.0.0:8889"
camera_name = "simulation"
# Initialize the client.
pipeline_client = PipelineClient(server_address)
# Collect the background for the given camera.
background_id = pipeline_client.collect_background(camera_name)
# Setup the pipeline config. Use the simulation camera as the pipeline source, and the collected background.
pipeline_config = {
"camera_name": camera_name,
"background_id": background_id
}
# Create a new pipeline with the provided configuration. Stream address in format tcp://hostname:port.
instance_id, pipeline_stream_address = pipeline_client.create_instance_from_config(
pipeline_config)
# Extract the stream hostname and port from the stream address.
pipeline_host, pipeline_port = get_host_port_from_stream_address(
pipeline_stream_address)
# Subscribe to the stream.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
# Receive next message.
data = stream.receive()
image_width = data.data.data["width"].value
image_height = data.data.data["height"].value
image_bytes = data.data.data["image"].value
print("Image size: %d x %d" % (image_width, image_height))
print("Image data: %s" % image_bytes)
x_size, y_size = get_simulated_camera().get_geometry()
self.assertIsNotNone(data)
self.assertEqual(image_width, x_size)
self.assertIsNotNone(image_height, y_size)
def get_image(camName, ROI, numImg, angle):
pipeline_client = PipelineClient()
pipeline_config = {"camera_name": camName, "image_region_of_interest": ROI}
pipeline_config = {"camera_name": camName,"rotation":angle}
instance_id, pipeline_stream_address = pipeline_client.create_instance_from_config(pipeline_config)
pipeline_host, pipeline_port = get_host_port_from_stream_address(pipeline_stream_address)
img = []
x_profile = []
y_profile = []
x_fwhm = []
y_fwhm = []
x_center_of_mass = []
y_center_of_mass = []
intensity = []
max_value = []
width = []
height = []
with source(host=pipeline_host, port=pipeline_port, mode=SUB) as stream:
for i in range(0,numImg):
data = stream.receive()
img.append(data.data.data["image"].value)
x_profile.append(data.data.data["x_profile"].value)
y_profile.append(data.data.data["y_profile"].value)
x_fwhm.append(data.data.data["x_fwhm"].value)
y_fwhm.append(data.data.data["y_fwhm"].value)
x_center_of_mass.append(data.data.data["x_center_of_mass"].value)
intensity.append(data.data.data["intensity"].value)
width.append(data.data.data["width"].value)
height.append(data.data.data["height"].value)
img = np.asarray(img)
dataout = {
"mean": img.mean(axis=0),
"image":img,
"x_profile":x_profile,
"y_profile":y_profile,
"x_fwhm":x_fwhm,
"y_fwhm":y_fwhm,
"x_center_of_mass":x_center_of_mass,
"y_center_of_mass":y_center_of_mass,
"intensity":intensity,
"max_value":max_value,
"width":width,
"height":height
}
return dataout
def _collect_camera_settings(self):
try:
#self.width_raw, self.height_raw = 659, 494
source_host, source_port = get_host_port_from_stream_address(self.bsread_stream_address)
stream = Source(host=source_host, port=source_port, mode=PULL,receive_timeout=3000)
stream.connect()
data = stream.receive()
image = data.data.data[self.camera_config.get_source() + config.EPICS_PV_SUFFIX_IMAGE].value
if image is None:
self.height_raw, self.width_raw = 0,0
else:
image = transform_image(image, self.camera_config)
self.height_raw, self.width_raw = image.shape
except:
raise RuntimeError("Could not fetch camera settings cam_server:{}".format(self.camera_config.get_source()))
finally:
stream.disconnect()
def test_a_quick_start(self):
from cam_server import PipelineClient
from cam_server.utils import get_host_port_from_stream_address
from bsread import source, SUB
# Create a pipeline client.
client = PipelineClient()
# ADDITIONAL, FOR THE TEST
camera_name = "simulation"
client = self.pipeline_client
client.create_instance_from_config(
configuration={"camera_name": camera_name},
instance_id=camera_name + "_sp1")
# Define the camera name you want to read. This should be the same camera you are streaming in screen panel.
camera_name = "simulation"
# Format of the instance id when screen_panel creates a pipeline.
pipeline_instance_id = camera_name + "_sp1"
# Get the stream for the pipelie instance.
stream_address = client.get_instance_stream(pipeline_instance_id)
# Extract the stream host and port from the stream_address.
stream_host, stream_port = get_host_port_from_stream_address(
stream_address)
# Open connection to the stream. When exiting the 'with' section, the source disconnects by itself.
with source(host=stream_host, port=stream_port,
mode=SUB) as input_stream:
input_stream.connect()
# Read one message.
message = input_stream.receive()
# Print out the received stream data - dictionary.
print("Dictionary with data:\n", message.data.data)
# Print out the X center of mass.
print("X center of mass: ",
message.data.data["x_center_of_mass"].value)
def get_instance_message(self, instance_id):
"""
Get a single message from a stream instance.
:param instance_id: Instance id of the stream.
:return: Message from the stream.
"""
instance_address = self.get_instance_stream(instance_id)
instance_config = self.get_instance_config(instance_id)
pipeline_type = instance_config["pipeline_type"]
if pipeline_type != "processing":
raise ValueError("Cannot get message from '%s' pipeline type." %
pipeline_type)
host, port = get_host_port_from_stream_address(instance_address)
with source(host=host, port=port, mode=SUB) as stream:
message = stream.receive()
return message
def start(self, stream, stream_mode=SUB):
self.stream = stream
try:
stream_host, stream_port = get_host_port_from_stream_address(
stream)
with source(host=stream_host, port=stream_port,
mode=stream_mode) as stream:
while True:
if (self.number_of_records >= 0) and (
self.current_record >= self.number_of_records):
break
rec = stream.receive()
pulse_id, data, format_changed, global_timestamp, global_timestamp_offset = \
rec.data.pulse_id, rec.data.data, rec.data.format_changed, rec.data.global_timestamp, \
rec.data.global_timestamp_offset
self.add_record(pulse_id, data, format_changed,
global_timestamp, global_timestamp_offset)
finally:
self.close()
def get_axis(screen):
camera_client = CamClient()
camera_stream_adress = camera_client.get_instance_stream(screen)
host, port = get_host_port_from_stream_address(camera_stream_adress)
max_tries = 3
for _try in range(max_tries):
try:
with source(host=host, port=port, mode=SUB) as stream:
data = stream.receive()
print('Received image')
x_axis = np.array(data.data.data['x_axis'].value) * 1e-6
y_axis = np.array(data.data.data['y_axis'].value) * 1e-6
except Exception as e:
print('Try %i' % _try, e)
pass
else:
break
else:
raise
return x_axis, y_axis
def get_request_server(self, status=None):
try:
servers = []
load = self.get_load(status)
loads = []
server_name, server_prefix, server_address = self.get_source()
for i in range(len(self.server_pool)):
if load[i] < 1000:
name = self.server_pool[i].get_address()
host, port = get_host_port_from_stream_address(name)
host_prefix = host.split(".")[0].lower() if host else None
local_host_name = socket.gethostname()
local_host_prefix = local_host_name.split(
".")[0].lower() if local_host_name else None
if server_address == "127.0.0.1":
if (host == "127.0.0.1") or (host_prefix
in (local_host_prefix,
"localhost")):
servers.append(self.server_pool[i])
loads.append(load[i])
elif server_prefix == host_prefix:
servers.append(self.server_pool[i])
loads.append(load[i])
elif server_address == host:
servers.append(self.server_pool[i])
loads.append(load[i])
#Balancing between servers in same machine to pass manager test
if len(servers) > 0:
m = min(loads)
return servers[loads.index(m)]
except Exception as e:
_logger.warning('Failed to identify request origin: ' + str(e))
return None
def store_pipeline(stop_event, statistics, parameter_queue, cam_client,
pipeline_config, output_stream_port, background_manager):
# TODO: Implement statistics: n_clients, input_throughput
def no_client_timeout():
_logger.warning(
"No client connected to the pipeline stream for %d seconds. Closing instance."
% config.MFLOW_NO_CLIENTS_TIMEOUT)
stop_event.set()
source = None
sender = None
try:
camera_stream_address = cam_client.get_camera_stream(
pipeline_config.get_camera_name())
camera_name = pipeline_config.get_camera_name()
_logger.debug("Connecting to camera %s on stream address %s.",
camera_name, camera_stream_address)
source_host, source_port = get_host_port_from_stream_address(
camera_stream_address)
source = Source(host=source_host,
port=source_port,
receive_timeout=config.PIPELINE_RECEIVE_TIMEOUT,
mode=SUB)
source.connect()
_logger.debug("Opening output stream on port %d.", output_stream_port)
sender = Sender(port=output_stream_port,
mode=PUSH,
data_header_compression=config.
CAMERA_BSREAD_DATA_HEADER_COMPRESSION,
block=False)
sender.open(no_client_action=no_client_timeout,
no_client_timeout=config.MFLOW_NO_CLIENTS_TIMEOUT)
# TODO: Register proper channels.
# Indicate that the startup was successful.
stop_event.clear()
_logger.debug("Transceiver started.")
while not stop_event.is_set():
try:
data = source.receive()
# In case of receiving error or timeout, the returned data is None.
if data is None:
continue
forward_data = {camera_name: data.data.data["image"].value}
pulse_id = data.data.pulse_id
timestamp = (data.data.global_timestamp,
data.data.global_timestamp_offset)
sender.send(data=forward_data,
pulse_id=pulse_id,
timestamp=timestamp)
except:
_logger.exception("Could not process message.")
stop_event.set()
_logger.info("Stopping transceiver.")
except:
_logger.exception(
"Exception while trying to start the receive and process thread.")
raise
finally:
if source:
source.disconnect()
if sender:
sender.close()
def test_client(self):
expected_pipelines = [
"pipeline_example_1", "pipeline_example_2", "pipeline_example_3",
"pipeline_example_4"
]
for pipeline in expected_pipelines:
self.assertIn(pipeline, self.pipeline_client.get_pipelines(),
"Test config pipelines have changed?")
expected_pipelines = set(self.pipeline_client.get_pipelines())
camera_config = self.pipeline_client.get_pipeline_config(
"pipeline_example_4")
self.pipeline_client.save_pipeline_config("testing_config",
camera_config)
with self.assertRaisesRegex(
ValueError, "Camera name not specified in configuration."):
self.pipeline_client.save_pipeline_config("testing_config", {})
with self.assertRaisesRegex(
ValueError, "Camera name not specified in configuration."):
self.pipeline_client.save_pipeline_config("testing_config",
{"invalid": "config"})
with self.assertRaisesRegex(
ValueError,
"pipeline_type 'invalid' not present in mapping. Available"):
self.pipeline_client.save_pipeline_config(
"testing_config", {
"camera_name": "simulation",
"pipeline_type": "invalid"
})
expected_pipelines.add("testing_config")
self.assertSetEqual(set(self.pipeline_client.get_pipelines()),
expected_pipelines,
"Testing config was not added.")
stream_address_1 = self.pipeline_client.get_instance_stream(
"testing_config")
stream_address_2 = self.pipeline_client.get_instance_stream(
"testing_config")
self.assertEqual(
len(self.pipeline_client.get_server_info()["active_instances"]), 1,
"Instance not started or too many instances started.")
with self.assertRaisesRegex(ValueError,
"Config updates cannot be empty."):
self.pipeline_client.set_instance_config("testing_config", {})
with self.assertRaisesRegex(
ValueError, "Cannot set config on a read only instance."):
self.pipeline_client.set_instance_config(
"testing_config", {"camera_name": "simulation"})
self.assertEqual(stream_address_1, stream_address_2,
"Stream addresses should be equal.")
self.pipeline_client.stop_instance("testing_config")
self.assertEqual(
len(self.pipeline_client.get_server_info()["active_instances"]), 0,
"The instance should be stopped.")
instance_id_1, instance_stream_1 = self.pipeline_client.create_instance_from_name(
"testing_config")
instance_id_2, instance_stream_2 = self.pipeline_client.create_instance_from_name(
"testing_config")
instance_info = self.pipeline_client.get_instance_info(instance_id_1)
self.assertTrue("last_start_time" in instance_info)
self.assertTrue("statistics" in instance_info)
with self.assertRaisesRegex(
ValueError,
"Cannot change the camera name on a running instance. "
"Stop the instance first."):
self.pipeline_client.set_instance_config(
instance_id_1, {"camera_name": "different_camera"})
self.pipeline_client.set_instance_config(
instance_id_2, {
"image_threshold": 99999,
"image_region_of_interest": [0, 200, 0, 200]
})
# Wait for the config update.
sleep(0.5)
pipeline_host, pipeline_port = get_host_port_from_stream_address(
instance_stream_2)
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
data = stream.receive()
self.assertIsNotNone(data,
"This should really not happen anymore.")
# shape 200, 200 -> Account for the region of interest change.
self.assertTrue(
numpy.array_equal(data.data.data["image"].value,
numpy.zeros(shape=(200, 200))),
"Array should be all zeros, because of the threshold config.")
# Adjust width and height with the region of interest.
self.assertEqual(data.data.data["width"].value, 200,
"Region of interest not takes into account.")
self.assertEqual(data.data.data["height"].value, 200,
"Region of interest not takes into account.")
self.assertNotEqual(instance_id_1, instance_id_2,
"Instances should be different.")
self.assertNotEqual(instance_stream_1, instance_stream_2,
"Stream addresses should be different.")
self.assertEqual(
len(self.pipeline_client.get_server_info()["active_instances"]), 2,
"Two instances should be running.")
instance_stream_3 = self.pipeline_client.get_instance_stream(
instance_id_2)
self.assertEqual(instance_stream_2, instance_stream_3,
"Stream addresses should be equal.")
self.assertEqual(
len(self.pipeline_client.get_server_info()["active_instances"]), 2,
"Two instances should be running, get does not increase the number of instances."
)
self.pipeline_client.create_instance_from_config(
{"camera_name": "simulation"})
self.pipeline_client.create_instance_from_config(
{"camera_name": "simulation"})
self.assertEqual(
len(self.pipeline_client.get_server_info()["active_instances"]), 4,
"Two new instances should be created.")
with self.assertRaisesRegex(
ValueError, "You must specify either the pipeline name or the "
"configuration for the pipeline."):
self.pipeline_client.create_instance_from_config({})
with self.assertRaisesRegex(
ValueError, "Camera name not specified in configuration."):
self.pipeline_client.create_instance_from_config(
{"invalid": "config"})
background_id = self.pipeline_client.collect_background("simulation")
expected_background_file = os.path.join(self.background_config_folder,
background_id + ".npy")
# Unfortunately there is not way of knowing (from client side) how many images were collected.
background_id_2 = self.pipeline_client.collect_background(
"simulation", 5)
self.assertNotEqual(background_id, background_id_2,
"Background should be different.")
with self.assertRaisesRegex(Exception, "n_images must be a number."):
self.pipeline_client.collect_background("simulation",
"invalid_number")
pipeline_config = {
"camera_name": "simulation",
"background_image": background_id
}
instance_id, stream_address = self.pipeline_client.create_instance_from_config(
pipeline_config)
instance_config = self.pipeline_client.get_instance_config(instance_id)
# We need to account for the expended config.
expected_config = {}
expected_config.update(PipelineConfig.DEFAULT_CONFIGURATION)
expected_config.update(pipeline_config)
self.assertDictEqual(expected_config, instance_config,
"Set and retrieved instances are not equal.")
instance_info = self.pipeline_client.get_instance_info(instance_id)
self.assertEqual(instance_info["instance_id"], instance_id,
"Requested and retireved instances are different.")
self.assertEqual(instance_info["stream_address"], stream_address,
"Different stream address.")
self.assertTrue(instance_info["is_stream_active"],
"Stream should be active.")
self.assertFalse(instance_info["read_only"],
"It should not be read only.")
self.assertEqual(instance_info["camera_name"], "simulation",
"Wrong camera name.")
self.assertDictEqual(instance_info["config"], expected_config,
"Config is not equal")
self.pipeline_client.stop_instance(instance_id)
with self.assertRaisesRegex(
ValueError, "Instance '%s' does not exist." % instance_id):
self.pipeline_client.get_instance_info(instance_id)
with self.assertRaisesRegex(
ValueError, "Instance 'invalid instance' does not exist."):
self.pipeline_client.get_instance_info("invalid instance")
self.assertTrue(os.path.exists(expected_background_file))
os.remove(expected_background_file)
self.pipeline_client.stop_all_instances()
self.assertTrue(
"testing_config" in self.pipeline_client.get_pipelines(),
"Pre requirement for next test.")
self.pipeline_client.delete_pipeline_config("testing_config")
self.assertFalse(
"testing_config" in self.pipeline_client.get_pipelines(),
"Pipeline should not exist anymore.")
instance_id, stream_address = self.pipeline_client.create_instance_from_config(
{
"camera_name": "simulation",
"image_threshold": 10
}, "custom_instance")
self.assertEqual(instance_id, "custom_instance",
"Custom instance not set properly.")
self.assertTrue(
self.pipeline_client.is_instance_running("custom_instance"),
"Instance with custom instance id not present.")
self.assertEqual(
self.pipeline_client.get_instance_config("custom_instance")
["image_threshold"], 10, "Config not set on custom instance id.")
with self.assertRaisesRegex(
ValueError,
"Instance with id 'custom_instance' is already present and running. "
"Use another instance_id or stop the current instance if you want "
"to reuse the same instance_id."):
self.pipeline_client.create_instance_from_config(
{"camera_name": "simulation"}, "custom_instance")
self.pipeline_client.stop_instance("custom_instance")
# The instance is now stopped, it should overwrite it.
self.pipeline_client.create_instance_from_config(
{
"camera_name": "simulation",
"image_threshold": 20
}, "custom_instance")
self.assertEqual(
self.pipeline_client.get_instance_config(
"custom_instance")["image_threshold"], 20,
"Instance with custom id not overwritten.")
self.pipeline_client.save_pipeline_config("testing_config", {
"camera_name": "simulation",
"image_threshold": 30
})
with self.assertRaisesRegex(
ValueError,
"Instance with id 'custom_instance' is already present and running. "
"Use another instance_id or stop the current instance if you want "
"to reuse the same instance_id."):
self.pipeline_client.create_instance_from_name(
"testing_config", "custom_instance")
self.assertEqual(
self.pipeline_client.get_instance_config("custom_instance")
["image_threshold"], 20, "Instance should not have changed.")
data = self.pipeline_client.get_instance_message("custom_instance")
self.assertIsNotNone(data)
self.assertTrue("image" in data.data.data)
self.pipeline_client.stop_instance("custom_instance")
self.pipeline_client.create_instance_from_name("testing_config",
"custom_instance")
self.assertEqual(
self.pipeline_client.get_instance_config("custom_instance")
["image_threshold"], 30, "Instance should have changed.")
background_1 = self.pipeline_client.collect_background("simulation")
background_2 = self.pipeline_client.collect_background("simulation")
self.assertNotEqual(background_1, background_2)
latest_background = self.pipeline_client.get_latest_background(
"simulation")
self.assertEqual(latest_background, background_2,
"Wrong background set as latest.")
with self.assertRaisesRegex(
ValueError,
"No background matches for the specified prefix 'does not exist'."
):
self.pipeline_client.get_latest_background("does not exist")
expected_cameras = [
'camera_example_1', 'camera_example_3', 'camera_example_2',
'camera_example_4', 'simulation', 'simulation2'
]
#self.assertEqual(set(self.pipeline_client.get_cameras()), set(expected_cameras),
# "Expected cameras not present.")
for camera in expected_cameras:
self.assertIn(camera, set(self.pipeline_client.get_cameras()),
"Not getting expected camera: " + camera)
configuration = {"camera_name": "simulation", "threshold": 50}
stream_address_1 = self.pipeline_client.get_instance_stream_from_config(
configuration)
stream_address_2 = self.pipeline_client.get_instance_stream_from_config(
configuration)
self.assertEqual(
stream_address_1, stream_address_2,
"Requesting the same config should give you the same instance.")
self.pipeline_client.stop_all_instances()
self.cam_client.stop_all_instances()
instance_id, stream_address = self.pipeline_client.create_instance_from_config(
{
"camera_name": "simulation",
"pipeline_type": "store",
'stream_port': 10000
})
with self.assertRaisesRegex(
ValueError, "Cannot get message from 'store' pipeline type."):
self.pipeline_client.get_instance_message(instance_id)
host, port = get_host_port_from_stream_address(stream_address)
with source(host=host, port=port, mode=PULL) as stream:
data = stream.receive()
self.assertIsNotNone(data)
self.assertEqual(
len(data.data.data), 1,
"Only the image should be present in the received data.")
self.assertTrue(
"simulation" + config.EPICS_PV_SUFFIX_IMAGE in data.data.data,
"Camera name should be used instead of 'image'.")
self.pipeline_client.stop_all_instances()
#Transparent pipeline
instance_id, instance_stream = self.pipeline_client.create_instance_from_name(
"simulation")
cfg = self.pipeline_client.get_instance_config(instance_id)
cfg["function"] = "transparent"
self.pipeline_client.set_instance_config(instance_id, cfg)
time.sleep(.5)
data = self.pipeline_client.get_instance_message(instance_id)
self.assertIsNotNone(data)
# Cam_server fields + processing_parameters
required_fields = set([
"image", "timestamp", "width", "height", "x_axis", "y_axis",
"processing_parameters"
])
self.assertSetEqual(required_fields, set(data.data.data.keys()),
"Bad transparent pipeline fields.")
self.pipeline_client.stop_all_instances()
time.sleep(1.0)
def test_update_instance_config_with_running(self):
instance_manager = get_test_pipeline_manager_with_real_cam()
instance_manager.background_manager = BackgroundImageManager(
self.background_folder)
pipeline_config = {"camera_name": "simulation"}
black_image = numpy.zeros(shape=(960, 1280))
pipeline_id, pipeline_stream_address = instance_manager.create_pipeline(
configuration=pipeline_config)
pipeline_host, pipeline_port = get_host_port_from_stream_address(
pipeline_stream_address)
# Collect from the pipeline.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
normal_image_data = stream.receive()
self.assertIsNotNone(normal_image_data,
"This should really not happen anymore.")
self.assertFalse(
numpy.array_equal(normal_image_data.data.data['image'].value,
black_image),
"There should be a non black image.")
self.assertEqual(normal_image_data.data.data["width"].value, 1280,
"Incorrect width.")
self.assertEqual(normal_image_data.data.data["height"].value, 960,
"Incorrect height.")
white_image = numpy.zeros(shape=(960, 1280))
white_image.fill(99999)
instance_manager.background_manager.save_background(
"white_background", white_image, append_timestamp=False)
instance_manager.update_instance_config(
pipeline_id, {"image_background": "white_background"})
# Give it some time to load the background.
sleep(0.5)
# Collect from the camera.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
image_data = stream.receive()
self.assertIsNotNone(image_data,
"This should really not happen anymore.")
# Because we didn't set the "image_background_enable" yet.
self.assertFalse(
numpy.array_equal(image_data.data.data["image"].value,
black_image),
"Background should not be yet applied.")
instance_manager.update_instance_config(pipeline_id, {
"image_background_enable": True,
"image_threshold": 0
})
# Give it some time to load the background.
sleep(0.5)
# Collect from the camera.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
black_image_data = stream.receive()
self.assertIsNotNone(black_image_data,
"This should really not happen anymore.")
self.assertTrue(
numpy.array_equal(black_image_data.data.data["image"].value,
black_image), "Now background should work.")
instance_manager.stop_all_instances()
def test_update_instance_config_with_running(self):
instance_manager = get_test_pipeline_manager_with_real_cam()
instance_manager.background_manager = BackgroundImageManager(
self.background_folder)
pipeline_config = {"camera_name": "simulation"}
x_size, y_size = get_simulated_camera().get_geometry()
black_image = numpy.zeros(shape=(y_size,
x_size)).astype(dtype="uint16")
pipeline_id, pipeline_stream_address = instance_manager.create_pipeline(
configuration=pipeline_config)
pipeline_host, pipeline_port = get_host_port_from_stream_address(
pipeline_stream_address)
# Collect from the pipeline.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
normal_image_data = stream.receive()
self.assertIsNotNone(normal_image_data,
"This should really not happen anymore.")
self.assertFalse(
numpy.array_equal(normal_image_data.data.data['image'].value,
black_image),
"There should be a non black image.")
self.assertEqual(normal_image_data.data.data["width"].value,
x_size, "Incorrect width.")
self.assertEqual(normal_image_data.data.data["height"].value,
y_size, "Incorrect height.")
white_image = numpy.zeros(shape=(y_size, x_size))
white_image.fill(65535)
instance_manager.background_manager.save_background(
"white_background", white_image, append_timestamp=False)
instance_manager.update_instance_config(
pipeline_id, {"image_background": "white_background"})
# Give it some time to load the background.
sleep(0.5)
# Collect from the camera.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
image_data = stream.receive()
self.assertIsNotNone(image_data,
"This should really not happen anymore.")
# Because we didn't set the "image_background_enable" yet.
self.assertFalse(
numpy.array_equal(image_data.data.data["image"].value,
black_image),
"Background should not be yet applied.")
instance_manager.update_instance_config(pipeline_id, {
"image_background_enable": True,
"image_threshold": 0
})
# Give it some time to load the background.
sleep(1.0)
# Collect from the camera.
with source(host=pipeline_host, port=pipeline_port,
mode=SUB) as stream:
black_image_data = stream.receive()
print(pipeline_host, pipeline_port)
self.assertIsNotNone(black_image_data,
"This should really not happen anymore.")
print("---")
print(black_image_data.data.data["image"].value.shape,
black_image_data.data.data["image"].value.dtype)
print(black_image.shape, black_image.dtype)
black_image.astype(dtype="uint16")
for i in range(len(black_image)):
for j in range(len(black_image[0])):
if black_image_data.data.data["image"].value[i][
j] != black_image[i][j]:
print(i, j,
black_image_data.data.data["image"].value[i][j],
black_image[i][j])
self.assertTrue(
numpy.array_equal(black_image_data.data.data["image"].value,
black_image), "Now background should work.")
instance_manager.stop_all_instances()
def test_camera_settings_change(self):
stream_address = self.instance_manager.get_instance_stream(
"simulation")
simulated_camera = CameraSimulation(CameraConfig("simulation"))
sim_x, sim_y = simulated_camera.get_geometry()
camera_host, camera_port = get_host_port_from_stream_address(
stream_address)
# Collect from the pipeline.
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
x_size = data.data.data["width"].value
y_size = data.data.data["height"].value
self.assertEqual(x_size, sim_x)
self.assertEqual(y_size, sim_y)
x_axis_1 = data.data.data["x_axis"].value
y_axis_1 = data.data.data["y_axis"].value
self.assertEqual(x_axis_1.shape[0], sim_x)
self.assertEqual(y_axis_1.shape[0], sim_y)
new_config = update_camera_config(
self.instance_manager.get_instance(
"simulation").get_configuration(), {"rotate": 1})
new_config = CameraConfig("simulation", new_config).get_configuration()
self.instance_manager.set_camera_instance_config(
"simulation", new_config)
sleep(0.5)
# Collect from the pipeline.
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
x_size = data.data.data["width"].value
y_size = data.data.data["height"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_size, sim_y)
self.assertEqual(y_size, sim_x)
x_axis_2 = data.data.data["x_axis"].value
y_axis_2 = data.data.data["y_axis"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_axis_2.shape[0], sim_y)
self.assertEqual(y_axis_2.shape[0], sim_x)
# The axis should just be switched.
self.assertTrue(numpy.array_equal(x_axis_1, y_axis_2))
self.assertTrue(numpy.array_equal(y_axis_1, x_axis_2))
new_config = update_camera_config(
self.instance_manager.get_instance(
"simulation").get_configuration(), {"camera_calibration": {}})
new_config = CameraConfig("simulation", new_config).get_configuration()
self.instance_manager.set_camera_instance_config(
"simulation", new_config)
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
x_size = data.data.data["width"].value
y_size = data.data.data["height"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_size, sim_y)
self.assertEqual(y_size, sim_x)
x_axis_3 = data.data.data["x_axis"].value
y_axis_3 = data.data.data["y_axis"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_axis_3.shape[0], sim_y)
self.assertEqual(y_axis_3.shape[0], sim_x)
self.instance_manager.stop_all_instances()
def test_client(self):
server_info = self.client.get_server_info()
self.assertIsNot(server_info["active_instances"],
"There should be no running instances.")
expected_cameras = set([
"camera_example_1", "camera_example_2", "camera_example_3",
"camera_example_4", "simulation"
])
self.assertSetEqual(set(self.client.get_cameras()), expected_cameras,
"Not getting all expected cameras")
camera_stream_address = self.client.get_camera_stream("simulation")
self.assertTrue(bool(camera_stream_address),
"Camera stream address cannot be empty.")
self.assertTrue(
"simulation" in self.client.get_server_info()["active_instances"],
"Simulation camera not present in server info.")
# Check if we can connect to the stream and receive data (in less than 2 seconds).
host, port = get_host_port_from_stream_address(camera_stream_address)
with source(host=host, port=port, receive_timeout=2000,
mode=SUB) as stream:
data = stream.receive()
self.assertIsNotNone(data, "Received data was none.")
required_fields = set(
["image", "timestamp", "width", "height", "x_axis", "y_axis"])
self.assertSetEqual(required_fields, set(data.data.data.keys()),
"Required fields missing.")
image = data.data.data["image"].value
x_size, y_size = CameraSimulation(
CameraConfig("simulation")).get_geometry()
self.assertListEqual(
list(image.shape), [y_size, x_size],
"Original and received image are not the same.")
self.assertEqual(data.data.data["width"].value, x_size,
"Width not correct.")
self.assertEqual(data.data.data["height"].value, y_size,
"Height not correct.")
# Stop the simulation instance.
self.client.stop_camera("simulation")
self.assertTrue(
"simulation"
not in self.client.get_server_info()["active_instances"],
"Camera simulation did not stop.")
self.client.get_camera_stream("simulation")
self.assertTrue(
"simulation" in self.client.get_server_info()["active_instances"],
"Camera simulation did not start.")
self.client.stop_all_cameras()
self.assertTrue(
"simulation"
not in self.client.get_server_info()["active_instances"],
"Camera simulation did not stop.")
example_1_config = self.client.get_camera_config("camera_example_1")
self.assertTrue(bool(example_1_config), "Cannot retrieve config.")
# Change the name to reflect tha camera.
example_1_config["name"] = "testing_camera"
self.client.set_camera_config("testing_camera", example_1_config)
testing_camera_config = self.client.get_camera_config("testing_camera")
self.assertDictEqual(example_1_config, testing_camera_config,
"Saved and loaded configs are not the same.")
geometry = self.client.get_camera_geometry("simulation")
simulated_camera = CameraSimulation(CameraConfig("simulation"))
size_x, size_y = simulated_camera.get_geometry()
self.assertListEqual(
geometry, [size_x, size_y],
'The geometry of the simulated camera is not correct.')
self.assertTrue("testing_camera" in self.client.get_cameras(),
"Testing camera should be present.")
self.client.delete_camera_config("testing_camera")
self.assertTrue("testing_camera" not in self.client.get_cameras(),
"Testing camera should not be present.")
# Test if it fails quickly enough.
with self.assertRaisesRegex(
ValueError,
"Camera with prefix EPICS_example_1 not online - Status None"):
self.client.get_camera_stream("camera_example_1")
self.assertTrue(self.client.is_camera_online("simulation"),
"Simulation should be always online")
self.assertFalse(self.client.is_camera_online("camera_example_1"),
"Epics not working in this tests.")
self.client.set_camera_config(
"simulation_temp", self.client.get_camera_config("simulation"))
stream_address = self.client.get_camera_stream("simulation_temp")
camera_host, camera_port = get_host_port_from_stream_address(
stream_address)
sim_x, sim_y = CameraSimulation(
CameraConfig("simulation")).get_geometry()
instance_info = self.client.get_server_info(
)["active_instances"]["simulation_temp"]
self.assertTrue("last_start_time" in instance_info)
self.assertTrue("statistics" in instance_info)
# Collect from the pipeline.
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
x_size = data.data.data["width"].value
y_size = data.data.data["height"].value
self.assertEqual(x_size, sim_x)
self.assertEqual(y_size, sim_y)
x_axis_1 = data.data.data["x_axis"].value
y_axis_1 = data.data.data["y_axis"].value
self.assertEqual(x_axis_1.shape[0], sim_x)
self.assertEqual(y_axis_1.shape[0], sim_y)
camera_config = self.client.get_camera_config("simulation_temp")
camera_config["rotate"] = 1
self.client.set_camera_config("simulation_temp", camera_config)
sleep(0.5)
# Collect from the pipeline.
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
x_size = data.data.data["width"].value
y_size = data.data.data["height"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_size, sim_y)
self.assertEqual(y_size, sim_x)
x_axis_2 = data.data.data["x_axis"].value
y_axis_2 = data.data.data["y_axis"].value
# We rotate the image for 90 degrees - X and Y size should be inverted.
self.assertEqual(x_axis_2.shape[0], sim_y)
self.assertEqual(y_axis_2.shape[0], sim_x)
self.client.delete_camera_config("simulation_temp")
image = self.client.get_camera_image("simulation")
self.assertGreater(len(image.content), 0)
image = self.client.get_camera_image_bytes("simulation")
dtype = image["dtype"]
shape = image["shape"]
bytes = base64.b64decode(image["bytes"].encode())
x_size, y_size = CameraSimulation(
CameraConfig("simulation")).get_geometry()
self.assertEqual(shape, [y_size, x_size])
image_array = numpy.frombuffer(bytes, dtype=dtype).reshape(shape)
self.assertIsNotNone(image_array)
self.client.stop_all_cameras()
def get_image(Device_params, numImg, angle=None):
if angle == None:
angle = 0
pipeline_client = PipelineClient()
# pipeline_config = {"camera_name": camName, "image_region_of_interest": ROI}
pipeline_config = {
"camera_name": Device_params['FullName'],
"rotation": angle
}
instance_id, pipeline_stream_address = pipeline_client.create_instance_from_config(
pipeline_config)
pipeline_host, pipeline_port = get_host_port_from_stream_address(
pipeline_stream_address)
img = []
x_profile = []
y_profile = []
x_fit_gauss_function = []
y_fit_gauss_function = []
x_fit_mean = []
y_fit_mean = []
x_fit_standard_deviation = []
y_fit_standard_deviation = []
x_fwhm = []
y_fwhm = []
x_center_of_mass = []
y_center_of_mass = []
intensity = []
max_value = []
width = []
height = []
with source(host=pipeline_host, port=pipeline_port, mode=SUB) as stream:
for i in range(0, numImg):
data = stream.receive()
img.append(data.data.data["image"].value)
x_profile.append(data.data.data["x_profile"].value)
y_profile.append(data.data.data["y_profile"].value)
x_fit_gauss_function.append(
data.data.data["x_fit_gauss_function"].value)
y_fit_gauss_function.append(
data.data.data["y_fit_gauss_function"].value)
x_fwhm.append(data.data.data["x_fwhm"].value)
y_fwhm.append(data.data.data["y_fwhm"].value)
x_center_of_mass.append(data.data.data["x_center_of_mass"].value)
y_center_of_mass.append(data.data.data["y_center_of_mass"].value)
x_fit_mean.append(data.data.data["x_fit_mean"].value)
y_fit_mean.append(data.data.data["y_fit_mean"].value)
x_fit_standard_deviation.append(
data.data.data["x_fit_standard_deviation"].value)
y_fit_standard_deviation.append(
data.data.data["y_fit_standard_deviation"].value)
intensity.append(data.data.data["intensity"].value)
width.append(data.data.data["width"].value)
height.append(data.data.data["height"].value)
max_value.append(data.data.data["max_value"].value)
print(list(data.data.data.keys()))
img = np.asarray(img)
# Take metedata
PhotonEnergy = ep.caget('SARUN08-UIND030:FELPHOTENE.VAL')
PulseEnergy = ep.caget('SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US')
ATT053 = ep.caget('SARFE10-OATT053:TRANS_RB')
APU044_x_pos = ep.caget('SARFE10-OAPU044:MOTOR_X.RBV')
APU044_y_pos = ep.caget('SARFE10-OAPU044:MOTOR_Y.RBV')
APU044_w_pos = ep.caget('SARFE10-OAPU044:MOTOR_W.RBV')
APU044_h_pos = ep.caget('SARFE10-OAPU044:MOTOR_H.RBV')
dataout = {
"mean": img.mean(axis=0),
"image": img,
"x_profile": x_profile,
"y_profile": y_profile,
"x_fwhm": x_fwhm,
"y_fwhm": y_fwhm,
"x_center_of_mass": x_center_of_mass,
"y_center_of_mass": y_center_of_mass,
"intensity": intensity,
"max_value": max_value,
"width": width,
"height": height,
"camera_name": Device_params['FullName'],
"Bit_depth": Device_params['BitDepth'],
"PhotonEnergy": PhotonEnergy,
"PulseEnergy": PulseEnergy,
"x_fit_gauss_function": x_fit_gauss_function,
"y_fit_gauss_function": y_fit_gauss_function,
"x_fit_mean": x_fit_mean,
"y_fit_mean": y_fit_mean,
"x_fit_standard_deviation": x_fit_standard_deviation,
"y_fit_standard_deviation": y_fit_standard_deviation,
"x_axis": data.data.data["x_axis"].value,
"y_axis": data.data.data["y_axis"].value,
"APU044_x_pos": APU044_x_pos,
"APU044_y_pos": APU044_y_pos,
"APU044_w_pos": APU044_w_pos,
"APU044_h_pos": APU044_h_pos,
"ATT053": ATT053
}
return dataout
def test_manager(self):
stream_address_1 = self.client.get_instance_stream("simulation")
stream_address_2 = self.client.get_instance_stream("simulation2")
#Check if streams are alive
camera_host, camera_port = get_host_port_from_stream_address(
stream_address_1)
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
for key in ["image", "width", "height"]:
self.assertIn(key, data.data.data.keys())
camera_host, camera_port = get_host_port_from_stream_address(
stream_address_2)
with source(host=camera_host, port=camera_port, mode=SUB) as stream:
data = stream.receive()
for key in ["image", "width", "height"]:
self.assertIn(key, data.data.data.keys())
server_info = self.proxy_client.get_servers_info()
status_info = self.proxy_client.get_status_info()
instance_info = self.proxy_client.get_instances_info()
#Check if streams are equally distributed
self.assertEqual(server_info[self.cam_server_address[0]]["load"], 1)
self.assertEqual(server_info[self.cam_server_address[1]]["load"], 1)
# Check if instance information is available for each server instance
for instance in server_info[self.cam_server_address[0]]["instances"]:
self.assertIn(instance, instance_info)
for instance in server_info[self.cam_server_address[1]]["instances"]:
self.assertIn(instance, instance_info)
self.client.stop_all_instances()
#Server Config
self.assertEqual(
self.proxy_client.get_config(), {
'http://0.0.0.0:8880': {
'expanding': True
},
'http://0.0.0.0:8881': {
'expanding': True
}
})
self.proxy_client.set_config({
'http://0.0.0.0:8880': {
'expanding': True
},
'http://0.0.0.0:8881': {
"instances": ["DUMMY"],
'expanding': False
}
})
stream_address_1 = self.client.get_instance_stream("simulation")
stream_address_2 = self.client.get_instance_stream("simulation2")
#Check if streams are alive
camera_host, camera_port = get_host_port_from_stream_address(
stream_address_1)
camera_host, camera_port = get_host_port_from_stream_address(
stream_address_2)
server_info = self.proxy_client.get_servers_info()
status_info = self.proxy_client.get_status_info()
instance_info = self.proxy_client.get_instances_info()
self.assertEqual(server_info[self.cam_server_address[0]]["load"], 2)
self.assertEqual(server_info[self.cam_server_address[1]]["load"], 0)
