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)