class Handler(Declarative.Handler):
slider_value_model = Model.PropertyModel(50)
def reset(self, widget: Declarative.UIWidget) -> None:
self.slider_value_model.value = 50
def __init__(self, document_controller, data_item):
ui = document_controller.ui
super().__init__(ui,
_("Recorder"),
parent_window=document_controller,
persistent_id="Recorder" + str(data_item.uuid))
self.__recorder = Recorder(document_controller, data_item)
self.ui = ui
self.document_controller = document_controller
self.__data_item = data_item
self._create_menus()
self.__record_button = ui.create_push_button_widget(_("Record"))
def thumbnail_widget_drag(mime_data, thumbnail, hot_spot_x,
hot_spot_y):
# use this convoluted base object for drag so that it doesn't disappear after the drag.
self.content.drag(mime_data, thumbnail, hot_spot_x, hot_spot_y)
display_item = document_controller.document_model.get_display_item_for_data_item(
data_item)
data_item_thumbnail_source = DataItemThumbnailWidget.DataItemThumbnailSource(
ui, display_item=display_item)
data_item_chooser_widget = DataItemThumbnailWidget.ThumbnailWidget(
ui, data_item_thumbnail_source, Geometry.IntSize(48, 48))
data_item_chooser_widget.on_drag = thumbnail_widget_drag
self.__recording_interval_property = Model.PropertyModel(1000)
self.__recording_count_property = Model.PropertyModel(20)
recording_period_widget = ui.create_line_edit_widget(
properties={"width": 60})
recording_period_widget.bind_text(
Binding.PropertyBinding(
self.__recording_interval_property,
"value",
converter=Converter.IntegerToStringConverter()))
recording_count_widget = ui.create_line_edit_widget(
properties={"width": 60})
recording_count_widget.bind_text(
Binding.PropertyBinding(
self.__recording_count_property,
"value",
converter=Converter.IntegerToStringConverter()))
row0 = ui.create_row_widget()
row0.add_stretch()
row0.add_spacing(8)
row0.add(self.__record_button)
row0.add_spacing(8)
row1 = ui.create_row_widget()
row1.add(ui.create_label_widget(_("Interval")))
row1.add_spacing(8)
row1.add(recording_period_widget)
row1.add_spacing(4)
row1.add(ui.create_label_widget(_("msec")))
row1.add_spacing(8)
row1.add_stretch()
row2 = ui.create_row_widget()
row2.add(ui.create_label_widget(_("Frames")))
row2.add_spacing(8)
row2.add(recording_count_widget)
row2.add_spacing(8)
row2.add_stretch()
column1 = ui.create_column_widget()
column1.add(row1)
column1.add_spacing(4)
column1.add(row2)
column1.add_spacing(4)
column1.add(row0)
button_row = ui.create_row_widget()
button_row.add_spacing(8)
button_row.add(data_item_chooser_widget)
button_row.add_spacing(8)
button_row.add_stretch()
button_row.add_spacing(8)
button_row.add(column1)
button_row.add_spacing(8)
def record_pressed():
if self.__recorder.recording_state == "recording":
self.__recorder.stop_recording()
else:
self.__recorder.start_recording(
time.time(),
self.__recording_interval_property.value / 1000,
self.__recording_count_property.value)
self.__record_button.on_clicked = record_pressed
column = self.content
column.add_spacing(6)
column.add(button_row)
column.add_spacing(6)
def live_state_changed(is_live: bool) -> None:
self.__record_button.enabled = is_live
def recording_state_changed(recording_state: str) -> None:
if recording_state == "recording":
self.__record_button.text = _("Stop")
else:
self.__record_button.text = _("Record")
def data_item_removed() -> None:
self.request_close()
self.__recorder.on_live_state_changed = live_state_changed
self.__recorder.on_recording_state_changed = recording_state_changed
self.__recorder.on_data_item_removed = data_item_removed
live_state_changed(data_item.is_live)
recording_state_changed("stopped")
def __init__(self, ui, hardware_source_key, filter=None):
self.hardware_sources_model = Model.PropertyModel(list())
self.hardware_source_index_model = Model.PropertyModel()
self.hardware_source_changed_event = Event.Event()
filter = filter if filter is not None else lambda x: True
def rebuild_hardware_source_list():
# keep selected item the same
old_index = self.hardware_source_index_model.value
old_hardware_source = self.hardware_sources_model.value[
old_index] if old_index is not None else None
items = list()
for hardware_source in HardwareSourceModule.HardwareSourceManager(
).hardware_sources:
if filter(hardware_source):
items.append(hardware_source)
self.hardware_sources_model.value = sorted(
items, key=operator.attrgetter("display_name"))
new_index = None
for index, hardware_source in enumerate(
self.hardware_sources_model.value):
if hardware_source == old_hardware_source:
new_index = index
break
new_index = new_index if new_index is not None else 0 if len(
self.hardware_sources_model.value) > 0 else None
self.hardware_source_index_model.value = new_index
self.hardware_source_changed_event.fire(self.hardware_source)
self.__hardware_source_added_event_listener = HardwareSourceModule.HardwareSourceManager(
).hardware_source_added_event.listen(
lambda h: rebuild_hardware_source_list())
self.__hardware_source_removed_event_listener = HardwareSourceModule.HardwareSourceManager(
).hardware_source_removed_event.listen(
lambda h: rebuild_hardware_source_list())
rebuild_hardware_source_list()
hardware_source_id = ui.get_persistent_string(hardware_source_key)
new_index = None
for index, hardware_source in enumerate(
self.hardware_sources_model.value):
if hardware_source.hardware_source_id == hardware_source_id:
new_index = index
break
new_index = new_index if new_index is not None else 0 if len(
self.hardware_sources_model.value) > 0 else None
self.hardware_source_index_model.value = new_index
self.hardware_source_changed_event.fire(self.hardware_source)
def update_current_hardware_source(key):
if key == "value":
hardware_source_id = self.hardware_sources_model.value[
self.hardware_source_index_model.value].hardware_source_id
ui.set_persistent_string(hardware_source_key,
hardware_source_id)
self.hardware_source_changed_event.fire(self.hardware_source)
self.__property_changed_event_listener = self.hardware_source_index_model.property_changed_event.listen(
update_current_hardware_source)
class Handler:
slider_value_model = Model.PropertyModel(50)
def reset(self, widget):
self.slider_value_model.value = 50
def __init__(self):
self.color_line_edit = None
self.model = Model.PropertyModel("red")
def __init__(self, ui_view, video_sources):
self.ui_view = ui_view
self.video_sources = video_sources
self.video_source_type_index = Model.PropertyModel(0)
def __init__(self) -> None:
super().__init__()
self.icon1 = make_icon(12, 12)
self.icon2 = make_icon(48, 36)
self.image_model = Model.PropertyModel(make_icon(16, 16), typing.cast(typing.Callable[[typing.Optional[IconType], typing.Optional[IconType]], bool], numpy.array_equal))
self.property_changed_event = Event.Event()
class Handler:
stack_index_model = Model.PropertyModel(1)
class Handler(Declarative.Handler):
tab_index_model = Model.PropertyModel(1)
def switch3(self, widget: Declarative.UIWidget) -> None:
print("CLICKED 3")
self.tab_index_model.value = 2
def __init__(self, document_controller: DocumentController.DocumentController, panel_id: str,
properties: Persistence.PersistentDictType, debounce: bool = True, sample: bool = True) -> None:
super().__init__(document_controller, panel_id, _("Histogram"))
def calculate_region_data(display_data_and_metadata: typing.Optional[DataAndMetadata.DataAndMetadata], region: Graphics.Graphic) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
if region is not None and display_data_and_metadata is not None:
if display_data_and_metadata.is_data_1d and isinstance(region, Graphics.IntervalGraphic):
interval = region.interval
if 0 <= interval[0] < 1 and 0 < interval[1] <= 1:
start, end = int(interval[0] * display_data_and_metadata.data_shape[0]), int(interval[1] * display_data_and_metadata.data_shape[0])
if end - start >= 1:
cropped_data_and_metadata = Core.function_crop_interval(display_data_and_metadata, interval)
if cropped_data_and_metadata:
return cropped_data_and_metadata
elif display_data_and_metadata.is_data_2d and isinstance(region, Graphics.RectangleTypeGraphic):
cropped_data_and_metadata = Core.function_crop(display_data_and_metadata, region.bounds.as_tuple())
if cropped_data_and_metadata:
return cropped_data_and_metadata
return display_data_and_metadata
def calculate_region_data_func(display_data_and_metadata: typing.Optional[DataAndMetadata.DataAndMetadata], region: Graphics.Graphic) -> typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]]:
return functools.partial(calculate_region_data, display_data_and_metadata, region)
def calculate_histogram_widget_data(display_data_and_metadata_func: typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]], display_range: typing.Optional[typing.Tuple[float, float]]) -> HistogramWidgetData:
bins = 320
subsample = 0 # hard coded subsample size
subsample_fraction = None # fraction of total pixels
subsample_min = 1024 # minimum subsample size
display_data_and_metadata = display_data_and_metadata_func()
display_data = display_data_and_metadata.data if display_data_and_metadata else None
if display_data is not None:
total_pixels = numpy.product(display_data.shape, dtype=numpy.uint64) # type: ignore
if not subsample and subsample_fraction:
subsample = min(max(total_pixels * subsample_fraction, subsample_min), total_pixels)
if subsample:
factor = total_pixels / subsample
data_sample = numpy.random.choice(display_data.reshape(numpy.product(display_data.shape, dtype=numpy.uint64)), subsample) # type: ignore
else:
factor = 1.0
data_sample = numpy.copy(display_data) # type: ignore
if display_range is None or data_sample is None:
return HistogramWidgetData()
histogram_data = factor * numpy.histogram(data_sample, range=display_range, bins=bins)[0] # type: ignore
histogram_max = numpy.max(histogram_data) # type: ignore # assumes that histogram_data is int
if histogram_max > 0:
histogram_data = histogram_data / float(histogram_max)
return HistogramWidgetData(histogram_data, display_range)
return HistogramWidgetData()
def calculate_histogram_widget_data_func(display_data_and_metadata_model_func: typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]], display_range: typing.Optional[typing.Tuple[float, float]]) -> typing.Callable[[], HistogramWidgetData]:
return functools.partial(calculate_histogram_widget_data, display_data_and_metadata_model_func, display_range)
display_item_stream = TargetDisplayItemStream(document_controller)
display_data_channel_stream = StreamPropertyStream[DisplayItem.DisplayDataChannel](typing.cast(Stream.AbstractStream[Observable.Observable], display_item_stream), "display_data_channel")
region_stream = TargetRegionStream(display_item_stream)
def compare_data(a: typing.Any, b: typing.Any) -> bool:
return numpy.array_equal(a.data if a else None, b.data if b else None) # type: ignore
display_data_and_metadata_stream = DisplayDataChannelTransientsStream[DataAndMetadata.DataAndMetadata](display_data_channel_stream, "display_data_and_metadata", cmp=compare_data)
display_range_stream = DisplayDataChannelTransientsStream[typing.Tuple[float, float]](display_data_channel_stream, "display_range")
region_data_and_metadata_func_stream = Stream.CombineLatestStream[typing.Any, typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]]]((display_data_and_metadata_stream, region_stream), calculate_region_data_func)
histogram_widget_data_func_stream: Stream.AbstractStream[typing.Callable[[], HistogramWidgetData]]
histogram_widget_data_func_stream = Stream.CombineLatestStream[typing.Any, typing.Callable[[], HistogramWidgetData]]((region_data_and_metadata_func_stream, display_range_stream), calculate_histogram_widget_data_func)
color_map_data_stream = StreamPropertyStream[_RGBA8ImageDataType](typing.cast(Stream.AbstractStream[Observable.Observable], display_data_channel_stream), "color_map_data", cmp=typing.cast(typing.Callable[[typing.Optional[T], typing.Optional[T]], bool], numpy.array_equal))
if debounce:
histogram_widget_data_func_stream = Stream.DebounceStream[typing.Callable[[], HistogramWidgetData]](histogram_widget_data_func_stream, 0.05, document_controller.event_loop)
if sample:
histogram_widget_data_func_stream = Stream.SampleStream[typing.Callable[[], HistogramWidgetData]](histogram_widget_data_func_stream, 0.5, document_controller.event_loop)
def cursor_changed_fn(canvas_x: typing.Optional[float], display_range: typing.Optional[typing.Tuple[float, float]]) -> None:
if not canvas_x:
document_controller.cursor_changed(None)
if display_item_stream and display_item_stream.value and canvas_x:
if display_range is not None: # can be None with empty data
displayed_intensity_calibration = display_item_stream.value.displayed_intensity_calibration
adjusted_x = display_range[0] + canvas_x * (display_range[1] - display_range[0])
adjusted_x_str = displayed_intensity_calibration.convert_to_calibrated_value_str(adjusted_x)
document_controller.cursor_changed([_('Intensity: ') + adjusted_x_str])
else:
document_controller.cursor_changed(None)
self.__histogram_widget_data_model = Model.FuncStreamValueModel(histogram_widget_data_func_stream, document_controller.event_loop, value=HistogramWidgetData())
self.__color_map_data_model: Model.PropertyModel[_RGBA8ImageDataType] = Model.StreamValueModel(color_map_data_stream, cmp=numpy.array_equal)
self._histogram_widget = HistogramWidget(document_controller, display_item_stream, self.__histogram_widget_data_model, self.__color_map_data_model, cursor_changed_fn)
def calculate_statistics(display_data_and_metadata_func: typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]], display_data_range: typing.Optional[typing.Tuple[float, float]], region: typing.Optional[Graphics.Graphic], displayed_intensity_calibration: typing.Optional[Calibration.Calibration]) -> typing.Dict[str, str]:
display_data_and_metadata = display_data_and_metadata_func()
data = display_data_and_metadata.data if display_data_and_metadata else None
data_range = display_data_range
if data is not None and data.size > 0 and displayed_intensity_calibration:
mean = numpy.mean(data)
std = numpy.std(data)
rms = numpy.sqrt(numpy.mean(numpy.square(numpy.absolute(data))))
dimensional_shape = Image.dimensional_shape_from_shape_and_dtype(data.shape, data.dtype) or (1, 1)
sum_data = mean * functools.reduce(operator.mul, dimensional_shape)
if region is None:
data_min, data_max = data_range if data_range is not None else (None, None)
else:
data_min, data_max = numpy.amin(data), numpy.amax(data)
mean_str = displayed_intensity_calibration.convert_to_calibrated_value_str(mean)
std_str = displayed_intensity_calibration.convert_to_calibrated_value_str(std)
data_min_str = displayed_intensity_calibration.convert_to_calibrated_value_str(data_min) if data_min is not None else str()
data_max_str = displayed_intensity_calibration.convert_to_calibrated_value_str(data_max) if data_max is not None else str()
rms_str = displayed_intensity_calibration.convert_to_calibrated_value_str(rms)
sum_data_str = displayed_intensity_calibration.convert_to_calibrated_value_str(sum_data)
return { "mean": mean_str, "std": std_str, "min": data_min_str, "max": data_max_str, "rms": rms_str, "sum": sum_data_str }
return dict()
def calculate_statistics_func(display_data_and_metadata_model_func: typing.Callable[[], typing.Optional[DataAndMetadata.DataAndMetadata]], display_data_range: typing.Optional[typing.Tuple[float, float]], region: typing.Optional[Graphics.Graphic], displayed_intensity_calibration: typing.Optional[Calibration.Calibration]) -> typing.Callable[[], typing.Dict[str, str]]:
return functools.partial(calculate_statistics, display_data_and_metadata_model_func, display_data_range, region, displayed_intensity_calibration)
display_data_range_stream = DisplayDataChannelTransientsStream[typing.Tuple[float, float]](display_data_channel_stream, "data_range")
displayed_intensity_calibration_stream = StreamPropertyStream[Calibration.Calibration](typing.cast(Stream.AbstractStream[Observable.Observable], display_item_stream), "displayed_intensity_calibration")
statistics_func_stream: Stream.AbstractStream[typing.Callable[[], typing.Dict[str, str]]]
statistics_func_stream = Stream.CombineLatestStream[typing.Any, typing.Callable[[], typing.Dict[str, str]]]((region_data_and_metadata_func_stream, display_data_range_stream, region_stream, displayed_intensity_calibration_stream), calculate_statistics_func)
if debounce:
statistics_func_stream = Stream.DebounceStream(statistics_func_stream, 0.05, document_controller.event_loop)
if sample:
statistics_func_stream = Stream.SampleStream(statistics_func_stream, 0.5, document_controller.event_loop)
self.__statistics_model = Model.FuncStreamValueModel(statistics_func_stream, document_controller.event_loop, value=typing.cast(typing.Dict[str, str], dict()))
self._statistics_widget = StatisticsWidget(self.ui, self.__statistics_model)
# create the main column with the histogram and the statistics section
column = self.ui.create_column_widget(properties={"height": 80 + 18 * 3 + 12})
column.add(self._histogram_widget)
column.add_spacing(6)
column.add(self._statistics_widget)
column.add_spacing(6)
column.add_stretch()
# this is necessary to make the panel happy
self.widget = column
def __init__(self,
document_controller: DocumentController.DocumentController):
super().__init__()
self.__document_controller = document_controller
self.title_model: Model.PropertyModel[str] = Model.PropertyModel(
_("Generated Data"))
self.data_type_model: Model.PropertyModel[int] = Model.PropertyModel(0)
self.is_sequence_model: Model.PropertyModel[int] = Model.PropertyModel(
0)
self.collection_rank_model: Model.PropertyModel[
int] = Model.PropertyModel(0)
self.datum_rank_model: Model.PropertyModel[int] = Model.PropertyModel(
1)
self.sequence_size_model: Model.PropertyModel[
int] = Model.PropertyModel(16)
self.line_size_model: Model.PropertyModel[int] = Model.PropertyModel(
512)
self.scan_width_model: Model.PropertyModel[int] = Model.PropertyModel(
256)
self.scan_height_model: Model.PropertyModel[int] = Model.PropertyModel(
256)
self.spectrum_size_model: Model.PropertyModel[
int] = Model.PropertyModel(1024)
self.image_width_model: Model.PropertyModel[int] = Model.PropertyModel(
1024)
self.image_height_model: Model.PropertyModel[
int] = Model.PropertyModel(1024)
self.array_width_model: Model.PropertyModel[int] = Model.PropertyModel(
1024)
self.array_height_model: Model.PropertyModel[
int] = Model.PropertyModel(256)
self.int_converter = Converter.IntegerToStringConverter()
u = Declarative.DeclarativeUI()
title_row = u.create_row(
u.create_label(text=_("Title")),
u.create_line_edit(text="@binding(title_model.value)"),
u.create_stretch(),
spacing=8)
data_type_row = u.create_row(
u.create_label(text=_("Data Type")),
u.create_combo_box(
items=["Float (32-bit)"],
current_index="@binding(data_type_model.value)"),
u.create_stretch(),
spacing=8)
is_sequence_row = u.create_row(
u.create_label(text=_("Sequence")),
u.create_combo_box(
items=["No", "Yes"],
current_index="@binding(is_sequence_model.value)"),
u.create_stretch(),
spacing=8)
not_sequence_column = u.create_column(
u.create_row(
u.create_label(text=_("No Sequence Axis"), enabled=False)))
sequence_column = u.create_column(
u.create_row(
u.create_label(text=_("Sequence Length")),
u.create_line_edit(
text=
"@binding(sequence_size_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
is_sequence_stack = u.create_stack(
not_sequence_column,
sequence_column,
current_index="@binding(is_sequence_model.value)")
collection_rank_row = u.create_row(
u.create_label(text=_("Collection Rank")),
u.create_combo_box(
items=["0 (none)", "1 (line)", "2 (scan)"],
current_index="@binding(collection_rank_model.value)"),
u.create_stretch(),
spacing=8)
no_scan_column = u.create_column(
u.create_row(
u.create_label(text=_("No Collection Axes"), enabled=False)))
line_column = u.create_column(
u.create_row(
u.create_label(text=_("Line Length")),
u.create_line_edit(
text=
"@binding(line_size_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
scan_column = u.create_column(
u.create_row(
u.create_label(text=_("Scan Width")),
u.create_line_edit(
text=
"@binding(scan_width_model.value, converter=int_converter)"
),
u.create_label(text=_("Scan Height")),
u.create_line_edit(
text=
"@binding(scan_height_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
collection_stack = u.create_stack(
no_scan_column,
line_column,
scan_column,
current_index="@binding(collection_rank_model.value)")
datum_rank_row = u.create_row(
u.create_label(text=_("Datum Rank")),
u.create_combo_box(
items=["1 (spectrum)", "2 (image)", "1+1 (array of 1d)"],
current_index="@binding(datum_rank_model.value)"),
u.create_stretch(),
spacing=8)
spectrum_column = u.create_column(
u.create_row(
u.create_label(text=_("Length")),
u.create_line_edit(
text=
"@binding(spectrum_size_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
image_column = u.create_column(
u.create_row(
u.create_label(text=_("Width")),
u.create_line_edit(
text=
"@binding(image_width_model.value, converter=int_converter)"
),
u.create_label(text=_("Height")),
u.create_line_edit(
text=
"@binding(image_height_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
array_column = u.create_column(
u.create_row(
u.create_label(text=_("Width")),
u.create_line_edit(
text=
"@binding(array_width_model.value, converter=int_converter)"
),
u.create_label(text=_("Height")),
u.create_line_edit(
text=
"@binding(array_height_model.value, converter=int_converter)"
),
u.create_stretch(),
spacing=8), )
datum_stack = u.create_stack(
spectrum_column,
image_column,
array_column,
current_index="@binding(datum_rank_model.value)")
button_row = u.create_row(u.create_stretch(),
u.create_push_button(
text=_("Cancel"),
on_clicked="close_window"),
u.create_push_button(text=_("Generate"),
on_clicked="generate"),
spacing=8)
main_page = u.create_column(title_row,
data_type_row,
is_sequence_row,
is_sequence_stack,
collection_rank_row,
collection_stack,
datum_rank_row,
datum_stack,
u.create_spacing(26),
button_row,
min_width=320 - 24)
window = u.create_window(main_page,
title=_("Generate Data"),
margin=12,
window_style="tool")
self.run(window,
parent_window=document_controller,
persistent_id="generate_data")
self.__document_controller.register_dialog(self.window)
class Handler:
radio_button_value = Model.PropertyModel(2)
label_widget = None
def reset_clicked(self, widget):
self.radio_button_value.value = 2
def __init__(self):
self.is_rejected = True
self.computation_index_model = Model.PropertyModel(current_item)
self.item_list = None
def __init__(self) -> None:
self.is_rejected = True
self.computation_index_model = Model.PropertyModel(current_item)
self.item_list: typing.Optional[typing.Any] = None
class Handler:
hello3_converter = Converter.FloatToStringConverter(format="{0:#.4g}")
hello3_model = Model.PropertyModel(5.6)
