class DateEditor(EditorFactory): """ Editor factory for date/time editors. """ # ------------------------------------------------------------------------- # Trait definitions: # ------------------------------------------------------------------------- # -- ReadonlyEditor traits ------------------------------------------------ #: Message to show when Date is None. message = Str("Undefined") #: The string representation of the date to show. Uses time.strftime #: format. strftime = Str("%B %d %Y (%a)") #: An optional view to display when a read-only text editor is clicked: view = AView # -- CustomEditor traits -------------------------------------------------- #: Should users be able to pick future dates when using the CustomEditor? allow_future = Bool(True) #: How many months to show at a time. months = Int(3) #: True: Must be a List of Dates. False: Must be a Date instance. multi_select = Bool(False) #: When a user multi-selects entries and some of those entries are already #: selected and some are not, what should be the behavior for the seletion? #: #: Options: #: #: - 'toggle': Toggle each day to the opposite of the current state. #: - 'on': Always turn them on. #: - 'off': Always turn them off. #: - 'max_change': Change all to same state, with most days changing. #: For example 1 selected and 9 not, then they would all get selected. #: - 'min_change': Change all to same state, with min days changing. #: For example 1 selected and 9 not, then they would all get unselected. on_mixed_select = Enum("toggle", "on", "off", "max_change", "min_change") #: How much space to put between the individual months. padding = Int(5) #: Does the user have to hold down Shift for the left-click multiselect? shift_to_select = Bool(False) #: Style used when a date is selected. selected_style = Instance( CellFormat, kw={ "bold": True, "fgcolor": (255, 255, 255), "bgcolor": (0, 128, 0) }, )
class BackgroundHandler(Handler): # The UIInfo object associated with the UI: info = Instance(UIInfo) # Is the demo currently running: running = Bool(True) # Is the thread still alive? alive = Bool(True) def init(self, info): self.info = info Thread(target=self._update).start() def closed(self, info, is_ok): self.running = False while self.alive: time.sleep(.05) def _update(self): try: while self.running: self.loop() time.sleep(0.1) except Exception: traceback.print_exc() os._exit(1) self.alive = False def loop(self): ''
class Array2DAdapter(TabularAdapter): columns = List show_index = Bool(True) count_from_one = Bool(True) ncolumns = Int data_format = Str('%s') font = 'Courier 10' alignment = 'right' format = data_format index_text = Property index_alignment = Property width = 60 def _get_index_text(self): return '- {} -'.format(self.row) def _get_index_alignment(self): return 'left' def _columns_default(self): if self.count_from_one: columns = [('%d' % (i + 1), i) for i in range(self.ncolumns)] else: columns = [('%d' % i, i) for i in range(self.ncolumns)] if self.show_index: columns.insert(0, ('items', 'index')) return columns
class PosteriorView(HasTraits): show_maximum = Bool(False) show_majority_vote = Bool(False) posterior_plot = Instance(PosteriorPlot) annotations = Array def traits_view(self): height = 760 if is_display_small() else 900 traits_view = View(VGroup(VGroup( Item('show_maximum', label='Show MAP estimate (circle)'), Item('show_majority_vote', label='Show majority vote (triangle)'), ), VGroup( Item('posterior_plot', editor=InstanceEditor(), style='custom', show_label=False), ), padding=0), height=height, scrollable=True, resizable=True) return traits_view def _show_maximum_changed(self): plot = self.posterior_plot if self.show_maximum: maximum = plot.posterior.argmax(1) plot.add_markings(maximum, 'MAP', 'circle', 0., 0., marker_size=3, line_width=2., marker_color='gray') else: plot.remove_markings('MAP') plot.plot_posterior.request_redraw() def _show_majority_vote_changed(self): plot = self.posterior_plot if self.show_majority_vote: majority = majority_vote(self.annotations) plot.add_markings(majority, 'majority', 'triangle', 0., 0., marker_size=3, line_width=1., marker_color='green') else: plot.remove_markings('majority') plot.plot_posterior.request_redraw()
class DateEditor(EditorFactory): """ Editor factory for date/time editors. """ #------------------------------------------------------------------------- # Trait definitions: #------------------------------------------------------------------------- #-- ReadonlyEditor traits ------------------------------------------------ # Message to show when Date is None. message = Str('Undefined') # The string representation of the date to show. Uses time.strftime # format. strftime = Str('%B %d %Y (%a)') # An optional view to display when a read-only text editor is clicked: view = AView #-- CustomEditor traits -------------------------------------------------- # Should users be able to pick future dates when using the CustomEditor? allow_future = Bool(True) # How many months to show at a time. months = Int(3) # True: Must be a List of Dates. False: Must be a Date instance. multi_select = Bool(False) # When a user multi-selects entries and some of those entries are already # selected and some are not, what should be the behavior for the seletion? # Options:: # # 'toggle' -- Toggle each day to the opposite of the current state. # 'on' -- Always turn them on. # 'off' -- Always turn them off. # 'max_change' -- Change all to same state, with most days changing. # For example 1 selected and 9 not, then they would # all get selected. # 'min_change' -- Change all to same state, with min days changing. # For example 1 selected and 9 not, then they would # all get unselected. on_mixed_select = Enum('toggle', 'on', 'off', 'max_change', 'min_change') # How much space to put between the individual months. padding = Int(5) # Does the user have to hold down Shift for the left-click multiselect? shift_to_select = Bool(False)
class VisibleWhenProblem(HasTraits): which = Enum("one", "two") on = Bool() txt = Str() onoff_group = HGroup( VGroup( Item("on", resizable=False, width=-100, height=-70), show_left=False, show_border=True, visible_when='which == "one"', ) ) text_group = VGroup( Item("txt", width=-_TEXT_WIDTH, height=-_TEXT_HEIGHT), visible_when='which == "two"', show_border=True, ) traits_view = View( Item("which"), VGroup(Include("onoff_group"), Include("text_group")), resizable=True, buttons=["OK", "Cancel"], )
class ExtendedListenerInList(HasTraits): # Used in regression test for enthought/traits#403. dummy = Instance(Dummy) changed = Bool(False) @on_trait_change(["dummy:x"]) def set_changed(self): self.changed = True
class ShowRightLabelsDialog(HasTraits): """Dialog with labels on the left/right to test the label text.""" bool_item = Bool(True) traits_view = View( VGroup( VGroup(Item("bool_item"), show_left=False), VGroup(Item("bool_item"), show_left=True), ))
class ButtonListView(HasStrictTraits): """ Provides a view for a dict of str:str conversions to Buttons Give this class a `dict`, and it will turn those `key:value` pairs into a view full of `Buttons`. Clicking any `Button` calls the `handler` with the key as the `event.name`. The keys must be strings that are usable as trait names; the values can be any string. """ #: Dict of trait-valid name strings as keys and any string as values traits_and_names = Dict #: Function to call when any of the resulting `Button` objects are clicked handler = Callable #: Class to use to create TraitsUI window to open controls view_klass = Any(default_value=View) #: Option setting the orientation of the buttons (default: "vertical") orientation = Orientation #: Name for the List Group group_label = Str #: Flag to set whether to allow scrolling scrollable = Bool(False) #: Internal list of trait names _trait_names = List #: List of tooltips (in the same order as `traits_and_names`) for buttons tooltips = List def __init__(self, **traits): super(ButtonListView, self).__init__(**traits) self._make_trait_names() def _make_trait_names(self): # add the trait names to this object, and connect the handler function for trait_name, label in self.traits_and_names.items(): self._trait_names.append(trait_name) self.add_trait(trait_name, Button(str(label))) self.observe(self.handler, trait_name) def traits_view(self): items = [Item(n, show_label=False) for n in self._trait_names] for i, tip in enumerate(self.tooltips): items[i].tooltip = tip return self.view_klass(Group(*items, label=self.group_label, orientation=self.orientation), scrollable=self.scrollable)
class CodeView(ModelView): model = Instance(CodeModel) show_line_numbers = Bool(True) style = Enum('simple', 'readonly') def default_traits_view(self): traits_view = View( Item('model.code', editor=CodeEditor(show_line_numbers=self.show_line_numbers), style=self.style)) return traits_view
class NoLabelResizeTestDialog(HasTraits): """ Test the combination show_label=False, show_left=False. """ bool_item = Bool(True) traits_view = View(VGroup(Item('bool_item', resizable=True, show_label=False), show_left=False), resizable=True)
class AbstractWnd(HasTraits): figure = Instance(Figure) def _figure_default(self): pass alive = Bool() auto_update = Bool(False) enable_update = Bool() start = Button() def _start_fired(self): self.enable_update = True Thread(target=self._loop).start() stop = Button() def _stop_fired(self): self.enable_update = False def _loop(self): if self.auto_update: while self.auto_update and self.enable_update: self._update() else: self._update() def _update(self): self.alive = True def stop_condition(t, tstart): return not self.enable_update data = self.measure(self.conf, stop_condition) self.alive = False fig = Figure() self.plot(data, fig) self.figure = fig
class Band(HasTraits): center = Int(enter_set=True, auto_set=False) threshold = Int(enter_set=True, auto_set=False) color = Color use = Bool(False) def traits_view(self): v = View( HGroup(UItem('use'), Item('center'), Item('threshold'), UItem('color'))) return v #============= EOF =============================================
class EnableWhenDialog(HasTraits): """ Test labels for enable when. """ bool_item = Bool(True) labelled_item = Str('test') unlabelled_item = Str('test') traits_view = View(VGroup( Item('bool_item', ), Item('labelled_item', enabled_when='bool_item'), Item('unlabelled_item', enabled_when='bool_item', show_label=False), ), resizable=True)
class VResizeTestDialog(HasTraits): """ Dialog with checkbox and text elements and labels on the right. We test the separation between element and label in VGroups. """ bool_item = Bool(True) txt_item = Str traits_view = View(VGroup( VGroup(Item('bool_item', resizable=True), show_left=False), VGroup(Item('txt_item', resizable=True), show_left=False), ), width=_DIALOG_WIDTH, height=100, resizable=True)
class EnableWhenDialog(HasTraits): """ Test labels for enable when. """ bool_item = Bool(True) labelled_item = Str("test") unlabelled_item = Str("test") traits_view = View( VGroup( Item("bool_item"), Item("labelled_item", enabled_when="bool_item"), Item("unlabelled_item", enabled_when="bool_item", show_label=False), ), resizable=True, )
class FluxTool(HasTraits): calculate_button = Button('Calculate') monitor_age = Property(depends_on='monitor') color_map_name = Str('jet') levels = Int(10, auto_set=False, enter_set=True) model_kind = Str('Plane') data_source = Str('database') # plot_kind = Str('Contour') plot_kind=Enum('Contour','Hole vs J') # def _plot_kind_default(self,): monitor=Any monitors=List group_positions=Bool(False) def _monitor_default(self): return DummyFluxMonitor() def _get_monitor_age(self): ma = 28.02e6 if self.monitor: ma=self.monitor.age return ma def traits_view(self): contour_grp = VGroup(Item('color_map_name', label='Color Map', editor=EnumEditor(values=sorted(color_map_name_dict.keys()))), Item('levels'), visible_when='plot_kind=="Contour"') monitor_grp=Item('monitor', editor=EnumEditor(name='monitors')) v = View( VGroup(HGroup(UItem('calculate_button'), UItem('data_source', editor=EnumEditor(values=['database', 'file'])), monitor_grp), HGroup(Item('group_positions'), Item('object.monitor.sample', style='readonly',label='Sample')), HGroup(UItem('plot_kind'), Item('model_kind', label='Fit Model', editor=EnumEditor(values=['Bowl', 'Plane']))), # UItem('plot_kind', editor=EnumEditor(values=['Contour', 'Hole vs J']))), contour_grp)) return v
class DialogWithToolbar(HasTraits): """Test dialog with toolbar and menu.""" action_successful = Bool(False) def test_clicked(self): self.action_successful = True menubar = MenuBar(Menu(ActionGroup(TestAction), name='&Test menu'), ) toolbar = ToolBar(ActionGroup(TestAction), ) traits_view = View( Item(label="Click the button on the toolbar or the menu item.\n" "The 'Action successful' element should turn to True."), Item('action_successful', style='readonly'), menubar=menubar, toolbar=toolbar, buttons=['OK'])
class DialogWithToolbar(HasTraits): """Test dialog with toolbar and menu.""" action_successful = Bool(False) def test_clicked(self): print("perform action") self.action_successful = True menubar = MenuBar(Menu(ActionGroup(TestAction), name="&Test menu")) toolbar = ToolBar(ActionGroup(TestAction)) traits_view = View( Item(label="Click the button on the toolbar or the menu item.\n" "The 'Action successful' element should turn to True."), Item("action_successful", style="readonly"), menubar=menubar, toolbar=toolbar, buttons=[TestAction, "OK"], )
class DelegateMess(HasTraits): dummy1 = Instance(Dummy, args=()) dummy2 = Instance(Dummy2) y = DelegatesTo("dummy2") handler_called = Bool(False) def _dummy2_default(self): # Create `self.dummy1` return Dummy2(dummy=self.dummy1) @on_trait_change("dummy1.x") def _on_dummy1_x(self): self.handler_called = True def _init_trait_listeners(self): """ Force the DelegatesTo listener to hook up first to exercise the worst case. """ for name in ["y", "_on_dummy1_x"]: data = self.__class__.__listener_traits__[name] getattr(self, "_init_trait_%s_listener" % data[0])(name, *data)
class DialogWithSchema(HasTraits): """Test dialog with toolbar and menu schemas.""" action_successful = Bool(False) def test_clicked(self): self.action_successful = True menubar = SMenuBar( SMenu( SGroup( ActionSchema( action_factory=lambda **traits: TestAction, ), ), name="&Test menu", ), ) toolbar = SToolBar( SGroup( ActionSchema( action_factory=lambda **traits: TestAction, ), ), ) traits_view = View( Item( label="Click the button on the toolbar or the menu item.\n" "The 'Action successful' element should turn to True." ), Item("action_successful", style="readonly"), menubar=menubar, toolbar=toolbar, buttons=[TestAction, "OK"], )
class FitSelector(HasTraits): fits = List(Fit) update_needed = Event suppress_refresh_unknowns = Bool save_event = Event fit_klass = Fit command_key = Bool auto_update = Bool(True) plot_button = Button('Plot') default_error_type = 'SD' show_all_button = Event show_state = Bool show_all_label = Property(depends_on='show_state') use_all_button = Button('Toggle Save') use_state = Bool global_fit = Str('Fit') global_error_type = Str('Error') fit_types = List(['Fit', ''] + FIT_TYPES) error_types = List(['Error', ''] + FIT_ERROR_TYPES) selected = Any def _get_show_all_label(self): return 'Hide All' if self.show_state else 'Show All' def _plot_button_fired(self): self.update_needed = True def _auto_update_changed(self): self.update_needed = True def _get_fits(self): fs = self.selected if not fs: fs = self.fits return fs def _show_all_button_fired(self): self.show_state = not self.show_state fs = self._get_fits() for fi in fs: fi.show = self.show_state def _use_all_button_fired(self): self.use_state = not self.use_state fs = self._get_fits() for fi in fs: fi.use = self.use_state def _global_fit_changed(self): if self.global_fit in self.fit_types: fs = self._get_fits() for fi in fs: fi.fit = self.global_fit def _global_error_type_changed(self): if self.global_error_type in FIT_ERROR_TYPES: fs = self._get_fits() for fi in fs: fi.error_type = self.global_error_type def _get_auto_group(self): return VGroup( HGroup( icon_button_editor( 'plot_button', 'refresh', tooltip='Replot the isotope evolutions. ' 'This may take awhile if many analyses are selected'), icon_button_editor('save_event', 'database_save', tooltip='Save fits to database'), Item( 'auto_update', label='Auto Plot', tooltip= 'Should the plot refresh after each change ie. "fit" or "show". ' 'It is not advisable to use this option with many analyses' )), HGroup( UItem('global_fit', editor=EnumEditor(name='fit_types')), UItem('global_error_type', editor=EnumEditor(name='error_types')))) def traits_view(self): v = View( VGroup(self._get_auto_group(), self._get_toggle_group(), self._get_fit_group())) return v def _get_toggle_group(self): g = HGroup( # UItem('global_fit',editor=EnumEditor(name='fit_types')), # UItem('global_error_type', editor=EnumEditor(name='error_types')), UItem('show_all_button', editor=ButtonEditor(label_value='show_all_label')), UItem('use_all_button')) return g def _get_columns(self): cols = [ ObjectColumn(name='name', editable=False), CheckboxColumn(name='show'), CheckboxColumn(name='use', label='Save'), ObjectColumn(name='fit', editor=EnumEditor(name='fit_types'), width=150), ObjectColumn(name='error_type', editor=EnumEditor(name='error_types'), width=50) ] return cols def _get_fit_group(self): cols = self._get_columns() editor = myTableEditor(columns=cols, selected='selected', selection_mode='rows', sortable=False, edit_on_first_click=False, clear_selection_on_dclicked=True, on_command_key=self._update_command_key, cell_bg_color='red', cell_font='modern 10') grp = UItem('fits', style='custom', editor=editor) return grp @on_trait_change('fits:[show, fit, use]') def _fit_changed(self, obj, name, old, new): if self.command_key: for fi in self.fits: fi.trait_set(**{name: new}) self.command_key = False if self.auto_update: if name in ('show', 'fit'): self.update_needed = True def load_fits(self, keys, fits): nfs = [] for ki, fi in zip(keys, fits): pf = next((fa for fa in self.fits if fa.name == ki), None) fit, et, fod = fi if pf is None: pf = self.fit_klass(name=ki) pf.fit = fit pf.filter_outliers = fod.get('filter_outliers', False) pf.filter_iterations = fod.get('iterations', 0) pf.filter_std_devs = fod.get('std_devs', 0) pf.error_type = et nfs.append(pf) self.fits = nfs # def load_baseline_fits(self, keys): # fits = self.fits # if not fits: # fits = [] # # fs = [ # self.fit_klass(name='{}bs'.format(ki), fit='average') # for ki in keys] # # fits.extend(fs) # self.fits = fits # def add_peak_center_fit(self): # fits = self.fits # if not fits: # fits = [] # # fs = self.fit_klass(name='PC', fit='average') # # fits.append(fs) # self.fits = fits # # def add_derivated_fits(self, keys): # fits = self.fits # if not fits: # fits = [] # # fs = [ # self.fit_klass(name='{}E'.format(ki), fit='average') # for ki in keys # ] # # fits.extend(fs) # self.fits = fits def _update_command_key(self, new): self.command_key = new
class ProjectInfoUI(cmp.project.ProjectInfo): """Class that extends the :class:`ProjectInfo` with graphical components. It supports graphically the setting of all processing properties / attributes of an :class:`ProjectInfo` instance. Attributes ----------- creation_mode : traits.Enum Mode for loading the dataset. Valid values are 'Load BIDS dataset', 'Install Datalad BIDS dataset' install_datalad_dataset_via_ssh : traits.Bool If set to True install the datalad dataset from a remote server via ssh.(True by default) ssh_user : traits.Str Remote server username. (Required if ``install_datalad_dataset_via_ssh`` is True) ssh_pwd <traits.Password> Remote server password. (Required if ``install_datalad_dataset_via_ssh`` is True) ssh_remote : traits.Str Remote server IP or URL. (Required if ``install_datalad_dataset_via_ssh`` is True) datalad_dataset_path : traits.Directory Path to the datalad dataset on the remote server. (Required if ``install_datalad_dataset_via_ssh`` is True) summary_view_button : traits.ui.Button Button that shows the pipeline processing summary table pipeline_processing_summary_view : traits.ui.VGroup TraitsUI VGroup that contains ``Item('pipeline_processing_summary')`` dataset_view : traits.ui.View TraitsUI View that shows a summary of project settings and modality available for a given subject traits_view : QtView TraitsUI QtView that includes the View 'dataset_view' create_view : traits.ui.View Dialog view to create a BIDS Dataset subject_view : traits.ui.View Dialog view to select of subject subject_session_view : traits.ui.View Dialog view to select the subject session dmri_bids_acq_view : traits.ui.View Dialog view to select the diffusion acquisition model anat_warning_view : traits.ui.View View that displays a warning message regarding the anatomical T1w data anat_config_error_view : traits.ui.View Error view that displays an error message regarding the configuration of the anatomical pipeline dmri_warning_view : traits.ui.View View that displays a warning message regarding the diffusion MRI data dmri_config_error_view : traits.ui.View View that displays an error message regarding the configuration of the diffusion pipeline fmri_warning_view : traits.ui.View View that displays a warning message regarding the functional MRI data fmri_config_error_view : traits.ui.View View that displays an error message regarding the configuration of the fMRI pipeline open_view : traits.ui.View Dialog view to load a BIDS Dataset anat_select_config_to_load : traits.ui.View Dialog view to load the configuration file of the anatomical pipeline diffusion_imaging_model_select_view : traits.ui.View Dialog view to select the diffusion acquisition model dmri_select_config_to_load : traits.ui.View Dialog view to load the configuration file of the diffusion MRI pipeline fmri_select_config_to_load : traits.ui.View Dialog view to load the configuration file of the fMRI pipeline """ creation_mode = Enum("Load BIDS dataset", "Install Datalad BIDS dataset") install_datalad_dataset_via_ssh = Bool(True) ssh_user = String("remote_username") ssh_pwd = Password("") ssh_remote = String("IP address/ Machine name") datalad_dataset_path = Directory( "/shared/path/to/existing/datalad/dataset") anat_runs = List() anat_run = Enum(values="anat_runs") dmri_runs = List() dmri_run = Enum(values="dmri_runs") fmri_runs = List() fmri_run = Enum(values="fmri_runs") summary_view_button = Button("Pipeline processing summary") pipeline_processing_summary_view = VGroup( Item("pipeline_processing_summary")) dataset_view = VGroup( VGroup( HGroup( Item( "base_directory", width=-0.3, style="readonly", label="", resizable=True, ), Item( "number_of_subjects", width=-0.3, style="readonly", label="Number of participants", resizable=True, ), "summary_view_button", ), label="BIDS Dataset", ), spring, HGroup( Group( Item("subject", style="simple", show_label=True, resizable=True)), Group( Item("subject_session", style="simple", label="Session", resizable=True), visible_when='subject_session!=""', ), springy=True, ), spring, Group( Item("t1_available", style="readonly", label="T1", resizable=True), HGroup( Item( "dmri_available", style="readonly", label="Diffusion", resizable=True, ), Item( "diffusion_imaging_model", label="Model", resizable=True, enabled_when="dmri_available", ), ), Item("fmri_available", style="readonly", label="BOLD", resizable=True), label="Modalities", ), spring, Group( Item( "anat_last_date_processed", label="Anatomical pipeline", style="readonly", resizable=True, enabled_when="t1_available", ), Item( "dmri_last_date_processed", label="Diffusion pipeline", style="readonly", resizable=True, enabled_when="dmri_available", ), Item( "fmri_last_date_processed", label="fMRI pipeline", style="readonly", resizable=True, enabled_when="fmri_available", ), label="Last date processed", ), spring, Group(Item("number_of_cores", resizable=True), label="Processing configuration"), "550", spring, springy=True, ) traits_view = QtView(Include("dataset_view")) create_view = View( Item("creation_mode", style="custom"), Group( Group( Item("base_directory", label="BIDS Dataset"), visible_when='creation_mode=="Load BIDS dataset"', ), Group( Item("install_datalad_dataset_via_ssh"), visible_when='creation_mode=="Install Datalad/BIDS dataset"', ), Group( Item( "ssh_remote", label="Remote ssh server", visible_when="install_datalad_dataset_via_ssh", ), Item( "ssh_user", label="Remote username", visible_when="install_datalad_dataset_via_ssh", ), Item( "ssh_pwd", label="Remote password", visible_when="install_datalad_dataset_via_ssh", ), Item( "datalad_dataset_path", label="Datalad/BIDS Dataset Path/URL to be installed", ), Item("base_directory", label="Installation directory"), visible_when='creation_mode=="Install Datalad/BIDS dataset"', ), ), kind="livemodal", title="Data creation: BIDS dataset selection", # style_sheet=style_sheet, width=modal_width, buttons=["OK", "Cancel"], ) subject_view = View( Group(Item("subject", label="Selected Subject")), kind="modal", title="Subject and session selection", # style_sheet=style_sheet, width=modal_width, buttons=["OK", "Cancel"], ) subject_session_view = View( Group( Item("subject", style="readonly", label="Selected Subject"), Item("subject_session", label="Selected Session"), ), kind="modal", title="Session selection", # style_sheet=style_sheet, width=modal_width, buttons=["OK", "Cancel"], ) dmri_bids_acq_view = View( Group(Item("dmri_bids_acq", label="Selected model"), ), kind="modal", title="Selection of diffusion acquisition model", # style_sheet=style_sheet, width=modal_width, buttons=["OK", "Cancel"], ) anat_warning_view = View( Group(Item("anat_warning_msg", style="readonly", show_label=False), ), title="Warning : Anatomical T1w data", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) anat_config_error_view = View( Group( Item("anat_config_error_msg", style="readonly", show_label=False), ), title="Error", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) dmri_warning_view = View( Group(Item("dmri_warning_msg", style="readonly", show_label=False), ), title="Warning : Diffusion MRI data", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) dmri_config_error_view = View( Group( Item("dmri_config_error_msg", style="readonly", show_label=False), ), title="Error", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) fmri_warning_view = View( Group(Item("fmri_warning_msg", style="readonly", show_label=False), ), title="Warning : fMRI data", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) fmri_config_error_view = View( Group( Item("fmri_config_error_msg", style="readonly", show_label=False), ), title="Error", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) open_view = View( Item("creation_mode", label="Mode"), Group( Item("install_datalad_dataset_via_ssh"), Item( "ssh_remote", label="Remote ssh server", visible_when="install_datalad_dataset_via_ssh", ), Item( "ssh_user", label="Remote username", visible_when="install_datalad_dataset_via_ssh", ), Item( "ssh_pwd", label="Remote password", visible_when="install_datalad_dataset_via_ssh", ), Item( "datalad_dataset_path", label="Datalad/BIDS Dataset Path/URL to be installed", ), Item("base_directory", label="Installation directory"), visible_when='creation_mode=="Install Datalad BIDS dataset"', ), Group( Item("base_directory", label="BIDS Dataset"), visible_when='creation_mode=="Load BIDS dataset"', ), kind="livemodal", title="BIDS Dataset Creation/Loading", # style_sheet=style_sheet, width=600, height=250, buttons=["OK", "Cancel"], ) anat_select_config_to_load = View( Group( Item("anat_config_to_load_msg", style="readonly", show_label=False), Item( "anat_config_to_load", style="custom", editor=EnumEditor(name="anat_available_config"), show_label=False, ), ), title="Select configuration for anatomical pipeline", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) anat_custom_map_view = View( Group( Item( "anat_custom_last_stage", editor=EnumEditor(name="anat_stage_names"), style="custom", show_label=False, ), ), title="Select until which stage to process the anatomical pipeline.", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) diffusion_imaging_model_select_view = View( Group(Item("diffusion_imaging_model", label="Diffusion MRI modality"), ), title="Please select diffusion MRI modality", kind="modal", width=modal_width, buttons=["OK", "Cancel"], ) dmri_select_config_to_load = View( Group( Item("dmri_config_to_load_msg", style="readonly", show_label=False), ), Item( "dmri_config_to_load", style="custom", editor=EnumEditor(name="dmri_available_config"), show_label=False, ), title="Select configuration for diffusion pipeline", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) dmri_custom_map_view = View( Group( Item( "dmri_custom_last_stage", editor=EnumEditor(name="dmri_stage_names"), style="custom", show_label=False, ), ), title="Select until which stage to process the diffusion pipeline.", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) fmri_select_config_to_load = View( Group( Item("fmri_config_to_load_msg", style="readonly", show_label=False), ), Item( "fmri_config_to_load", style="custom", editor=EnumEditor(name="fmri_available_config"), show_label=False, ), title="Select configuration for fMRI pipeline", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) fmri_custom_map_view = View( Group( Item( "fmri_custom_last_stage", editor=EnumEditor(name="fmri_stage_names"), style="custom", show_label=False, ), ), title="Select until which stage to process the fMRI pipeline.", kind="modal", width=modal_width, # style_sheet=style_sheet, buttons=["OK", "Cancel"], ) def _summary_view_button_fired(self): self.configure_traits(view="pipeline_processing_summary_view")
class BoardWrapper(HasTraits): pins = List(PinWrapper) digital_pins = List(PinWrapper) analog_pins = List(PinWrapper) defines = List(GuiDefine) port_type = Enum('serial', [ 'none', 'serial', ] ) serial_device = Enum(_auto_detect_serial_unix()) baudrate = Int(115200) sleep_after_connect = Int(2) timeout = Int(1) uptime = Float() tree = None vcc = Float() avr_name = Str() arduino_version = Str() firmware_build_time = Str() gcc_version = Str() libc_version = Str() libc_date = Str() connected = Bool(False) connect = Button() disconnect = Button() def _connect_fired(self): try: connection = SerialManager(device=self.serial_device, baudrate=self.baudrate, sleep_after_connect=self.sleep_after_connect, timeout=self.timeout) connection.open() print ArduinoApi(connection=connection).millis() except Exception as e: traceback.print_exc() message(traceback.format_exc(), buttons=['OK']) return a = self.tree = ArduinoTree(connection=connection) d = a.define.as_dict s = [GuiDefine(name=k, value=str(v)) for k, v in d.items()] s.sort(key=lambda x: x.name) self.defines = s self.digital_pins = [PinWrapper(pin=a.pin.get(x)) for x in a.pin.names_digital] self.analog_pins = [PinWrapper(pin=a.pin.get(x)) for x in a.pin.names_analog] self.pins = self.digital_pins + self.analog_pins fw = a.firmware_info self.arduino_version = fw.get('arduino_version') self.firmware_build_time = str(fw.get('compile_datetime')) self.avr_name = fw.get('avr_name') self.gcc_version = fw.get('gcc_version') self.libc_version = fw.get('libc_version') self.libc_date = str(fw.get('libc_date')) self.connected = True def _disconnect_fired(self): self.digital_pins = [] self.analog_pins = [] self.pins = [] self.defines = [] self.avr_name = '' self.arduino_version = '' self.firmware_build_time = '' self.gcc_version = '' self.libc_version = '' self.libc_date = '' self.tree.connection.close() del self.tree self.tree = None self.connected = False update_interval = Int(1000, desc='interval in msec') update_enable = Bool(True) def update(self): if self.update_enable and self.connected and self.tree: for x in self.pins: x.update() self.uptime = self.tree.api.millis() / 1000.0 self.vcc = self.tree.vcc.read() if self.tree.vcc else -1 time.sleep(self.update_interval / 1000.0) traits_view = View( Tabbed( Group( HGroup( Group( button('connect', enabled_when='not connected'), button('disconnect', enabled_when='connected'), Item( 'port_type', enabled_when='not connected', width=300, ), Group( 'serial_device', 'baudrate', 'sleep_after_connect', 'timeout', visible_when='port_type=="serial"', enabled_when='not connected', ), ), Group( 'avr_name', 'arduino_version', 'firmware_build_time', 'gcc_version', 'libc_version', 'libc_date', # 'baudrate', # 'sleep_after_connect', # visible_when='port_type=="serial"', springy=True, ), ), label='connection', ), Group( 'uptime', 'vcc', label='misc', ), Item(name='digital_pins', editor=ListEditor( style='custom', ), style='readonly', show_label=False, ), Item(name='analog_pins', editor=ListEditor( style='custom', ), style='readonly', show_label=False, ), Group( 'update_enable', Item(name='update_interval', editor=RangeEditor( mode='slider', low=1, high=1000, ), style='custom', ), label='settings', ), Item('defines', show_label=False, editor=ListEditor( # auto_size=False, # editable=False, # configurable=False, style='custom', ), style='readonly', ) ), width=800, height=600, buttons=['Undo', 'Revert', 'OK', 'Cancel'], kind='live', resizable=True, handler=Handler(), )
print ports class BoardWrapper(HasTraits): port = Enum(ports) def _port_changed(self): if self.serialobj: self.serialobj.close() self.serialobj = None try: self.serialobj = serial.Serial(self.port) except serial.serialutil.SerialException, e: print '%s %s' % (self.port, e) DCD = Bool(label='DCD (1)', desc='Data Carrier Detect') # RxD = String(label='RxD (2)') # TxD = String(label='TxD (3)') DTR = Bool(label='DTR (4)', desc='Data Terminal Ready') # GND = String(label='GND (5)') DSR = Bool(label='DSR (6)', desc='Data Set Ready') RTS = Bool(label='RTS (7)', desc='Request to Send') CTS = Bool(label='CTS (8)', desc='Clear To Send') RI = Bool(label='RI (9)', desc='Ring Indicator') serialobj = None update_interval = Int(100, desc='interval in msec') def update(self): if self.serialobj: self.DSR = self.serialobj.getDSR()
class DeviceConfigurer(Loggable): config_path = Str config_name = Str save_button = Button _config = None kind = Enum('ethernet', 'serial') communication_grp = Instance(CommunicationGroup) scan_grp = Instance(ScanGroup, ()) comms_visible = Bool(False) def set_device(self, device): p = device.config_path self._load_configuration(p) def _load_configuration(self, path): self.config_path = path self.config_name = os.path.relpath(path, paths.device_dir) self._config = cfg = six.moves.configparser.ConfigParser() cfg.read(path) section = 'Communications' if cfg.has_section(section): kind = cfg.get(section, 'type') klass = CKLASS_DICT.get(kind) if klass: self.communication_grp = klass() def func(option, cast=None, default=None, **kw): f = getattr(cfg, 'get{}'.format(cast if cast else '')) try: v = f(section, option, **kw) except six.moves.configparser.NoOptionError: v = default if v is None: if cast == 'boolean': v = False elif cast in ('float', 'int'): v = 0 return v self.communication_grp.load_from_config(func) self.communication_grp.config_obj = cfg self.comms_visible = True else: self.comms_visible = False self.communication_grp = CommunicationGroup() section = 'Scan' if cfg.has_section(section): bfunc = lambda *args: cfg.getboolean(*args) ffunc = lambda *args: cfg.getfloat(*args) else: bfunc = lambda *args: False ffunc = lambda *args: 0 sgrp = self.scan_grp for attr in ('enabled', 'graph', 'record', 'auto_start'): try: v = bfunc(section, attr) except six.moves.configparser.NoOptionError: v = False setattr(sgrp, attr, v) for attr in ('period', ): try: v = ffunc(section, attr) except six.moves.configparser.NoOptionError: v = 0 setattr(sgrp, attr, v) def _save_button_fired(self): self._dump() def _dump(self): # backup previous file # putting the device dir under git control is a good idea self._backup() with open(self.config_path, 'w') as wfile: self._config.write(wfile) def _backup(self): bp, pp = backup(self.config_path, paths.backup_device_dir, extension='.cfg') self.info('{} - saving a backup copy to {}'.format(bp, pp))
class FitSelector(HasTraits): fits = List(Fit) update_needed = Event suppress_refresh_unknowns = Bool save_event = Event fit_klass = Fit command_key = Bool auto_update = Bool(True) plot_button = Button('Plot') def _plot_button_fired(self): self.update_needed = True def _auto_update_changed(self): self.update_needed = True def _get_auto_group(self): return HGroup( icon_button_editor( 'plot_button', 'chart_curve_go', tooltip='Replot the isotope evolutions. ' 'This may take awhile if many analyses are selected'), icon_button_editor('save_event', 'database_save', tooltip='Save fits to database'), spring, Item( 'auto_update', label='Auto Plot', tooltip= 'Should the plot refresh after each change ie. "fit" or "show". ' 'It is not advisable to use this option with many analyses')) def traits_view(self): v = View(VGroup(self._get_auto_group(), self._get_fit_group())) return v def _get_columns(self): cols = [ ObjectColumn(name='name', editable=False), CheckboxColumn(name='show'), ObjectColumn(name='fit', editor=EnumEditor(name='fit_types'), width=150), ObjectColumn(name='error_type', editor=EnumEditor(name='error_types'), width=50), CheckboxColumn(name='use', label='Save DB') ] return cols def _get_fit_group(self): cols = self._get_columns() editor = myTableEditor(columns=cols, sortable=False, on_command_key=self._update_command_key) grp = UItem('fits', style='custom', editor=editor) return grp @on_trait_change('fits:[show, fit, use]') def _fit_changed(self, obj, name, old, new): if self.command_key: for fi in self.fits: fi.trait_set(trait_change_notify=False, **{name: new}) if self.auto_update: if name in ('show', 'fit'): self.update_needed = True def load_fits(self, keys, fits): nfs = [] for ki, fi in zip(keys, fits): pf = next((fa for fa in self.fits if fa.name == ki), None) if pf is None: pf = self.fit_klass(name=ki, fit=fi) else: pf.fit = fi nfs.append(pf) self.fits = nfs # self.fits = [ # self.fit_klass(name=ki, fit=fi) # for ki, fi in zip(ks, fs) # ] def load_baseline_fits(self, keys): fits = self.fits if not fits: fits = [] fs = [ self.fit_klass(name='{}bs'.format(ki), fit='average') for ki in keys ] fits.extend(fs) self.fits = fits def add_peak_center_fit(self): fits = self.fits if not fits: fits = [] fs = self.fit_klass(name='PC', fit='average') fits.append(fs) self.fits = fits def add_derivated_fits(self, keys): fits = self.fits if not fits: fits = [] fs = [ self.fit_klass(name='{}E'.format(ki), fit='average') for ki in keys ] fits.extend(fs) self.fits = fits def _update_command_key(self, new): self.command_key = new
class MarkerLabel(Label): rotate_angle = 0 zero_y = 0 xoffset = 10 indicator_width = 4 indicator_height = 10 visible = Bool(True) component_height = 100 x = Float y = Float data_y = Float vertical = False horizontal_line_visible = False label_with_intensity = False text = Property(depends_on='_text, label_with_intensity') _text = Str def _set_text(self, text): self._text = text def _get_text(self): if self.label_with_intensity: return '{:0.4f}'.format(self.data_y) else: return self._text def draw(self, gc, component_height): if not self.text: self.text = '' if self.bgcolor != "transparent": gc.set_fill_color(self.bgcolor_) #draw tag border with gc: if self.vertical: self.rotate_angle = 90 width, height = self.get_bounding_box(gc) gc.translate_ctm(self.x, self.zero_y_vert - 35 - height) else: if self.horizontal_line_visible: self._draw_horizontal_line(gc) gc.translate_ctm(self.x + self.xoffset, self.y) self._draw_tag_border(gc) super(MarkerLabel, self).draw(gc) with gc: gc.translate_ctm(self.x - self.indicator_width / 2.0, self.zero_y) self._draw_index_indicator(gc, component_height) def _draw_horizontal_line(self, gc): with gc: # print self.x, self.y gc.set_stroke_color((0, 0, 0, 1)) gc.set_line_width(2) oy = 7 if self.text else 4 y = self.y + oy gc.move_to(0, y) gc.line_to(self.x, y) gc.stroke_path() def _draw_index_indicator(self, gc, component_height): # gc.set_fill_color((1, 0, 0, 1)) w, h = self.indicator_width, self.indicator_height gc.draw_rect((0, 0, w, h), FILL) gc.draw_rect((0, component_height, w, h), FILL) def _draw_tag_border(self, gc): gc.set_stroke_color((0, 0, 0, 1)) gc.set_line_width(2) # gc.set_fill_color((1, 1, 1, 1)) bb_width, bb_height = self.get_bounding_box(gc) offset = 2 xoffset = self.xoffset gc.lines([(-xoffset, (bb_height + offset) / 2.0), (0, bb_height + 2 * offset), (bb_width + offset, bb_height + 2 * offset), (bb_width + offset, -offset), (0, -offset), (-xoffset, (bb_height + offset) / 2.0)]) gc.draw_path()
class ModelDataView(ModelView): #### Information about available models model_name = Enum( 'Model B-with-theta', 'Model B-with-theta (loop design)', 'Model B', 'Model A (loop design)', ) _model_name_to_class = { 'Model B-with-theta': ModelBt, 'Model B-with-theta (loop design)': ModelBtLoopDesign, 'Model B': ModelB, 'Model A (loop design)': ModelA } _model_class_to_view = { ModelBt: ModelBtView, ModelBtLoopDesign: ModelBtLoopDesignView, ModelB: ModelBView, ModelA: ModelAView } #### Application-related traits # reference to pyanno application application = Any #### Model-related traits # the annotations model model = Any # Traits UI view of the model model_view = Instance(ModelView) # fired when the model is updates model_updated = Event # parameters view should not update when this trait is False model_update_suspended = Bool(False) #### Annotation-related traits # File trait to load a new annotations file annotations_file = File # True then annotations are loaded correctly annotations_are_defined = Bool(False) # fired when annotations are updated annotations_updated = Event # Traits UI view of the annotations annotations_view = Instance(AnnotationsView) # Traits UI view of the annotations' statistics annotations_stats_view = Instance(AnnotationsStatisticsView) # shortcut to the annotations annotations = Property def _get_annotations(self): return self.annotations_view.annotations_container.annotations # property that combines information from the model and the annotations # to give a consistent number of classes nclasses = Property def _get_nclasses(self): return max(self.model.nclasses, self.annotations.max() + 1) # info string -- currently not used info_string = Str # used to display the current log likelihood log_likelihood = Float def _annotations_view_default(self): anno = AnnotationsContainer.from_array([[0]], name='<undefined>') return AnnotationsView(annotations_container=anno, nclasses=self.model.nclasses, application=self.application, model=HasTraits()) @on_trait_change('annotations_file') def _update_annotations_file(self): logger.info('Load file {}'.format(self.annotations_file)) anno = AnnotationsContainer.from_file(self.annotations_file) self.set_annotations(anno) @on_trait_change('annotations_updated,model_updated') def _update_log_likelihood(self): if self.annotations_are_defined: if not self.model.are_annotations_compatible(self.annotations): self.log_likelihood = np.nan else: self.log_likelihood = self.model.log_likelihood( self.annotations) @on_trait_change('model.nclasses') def _update_nclasses(self): self.annotations_view.nclasses = self.model.nclasses self.annotations_view.annotations_updated = True @on_trait_change('model,model:theta,model:gamma') def _fire_model_updated(self): if not self.model_update_suspended: self.model_updated = True if self.model_view is not None: self.model_view.model_updated = True ### Control content ####################################################### def set_model(self, model): """Update window with a new model. """ self.model = model model_view_class = self._model_class_to_view[model.__class__] self.model_view = model_view_class(model=model) self.model_updated = True def set_annotations(self, annotations_container): """Update window with a new set of annotations.""" self.annotations_view = AnnotationsView( annotations_container=annotations_container, nclasses=self.model.nclasses, application=self.application, model=HasTraits()) self.annotations_stats_view = AnnotationsStatisticsView( annotations=self.annotations, nclasses=self.nclasses) self.annotations_are_defined = True self.annotations_updated = True def set_from_database_record(self, record): """Set main window model and annotations from a database record.""" self.set_model(record.model) self.set_annotations(record.anno_container) ### Actions ############################################################## #### Model creation actions # create a new model new_model = Button(label='Create...') # show informations about the selected model get_info_on_model = Button(label='Info...') #### Annotation creation actions # create new annotations new_annotations = Button(label='Create...') #### Model <-> data computations # execute Maximum Likelihood estimation of parameters ml_estimate = Button(label='ML estimate...', desc=('Maximum Likelihood estimate of model ' 'parameters')) # execute MAP estimation of parameters map_estimate = Button(label='MAP estimate...') # draw samples from the posterior over accuracy sample_posterior_over_accuracy = Button(label='Sample parameters...') # compute posterior over label classes estimate_labels = Button(label='Estimate labels...') #### Database actions # open database window open_database = Button(label="Open database") # add current results to database add_to_database = Button(label="Add to database") def _new_model_fired(self): """Create new model.""" # delegate creation to associated model_view model_name = self.model_name model_class = self._model_name_to_class[model_name] responsible_view = self._model_class_to_view[model_class] # if annotations are loaded, set default values for number of # annotations and annotators to the ones in the data set kwargs = {} if self.annotations_are_defined: anno = self.annotations_view.annotations_container kwargs['nclasses'] = anno.nclasses kwargs['nannotators'] = anno.nannotators # model == None if the user cancelled the action model = responsible_view.create_model_dialog(self.info.ui.control, **kwargs) if model is not None: self.set_model(model) def _new_annotations_fired(self): """Create an empty annotations set.""" annotations = CreateNewAnnotationsDialog.create_annotations_dialog() if annotations is not None: name = self.application.database.get_available_id() anno_cont = AnnotationsContainer.from_array(annotations, name=name) self.set_annotations(anno_cont) def _open_database_fired(self): """Open database window.""" if self.application is not None: self.application.open_database_window() def _get_info_on_model_fired(self): """Open dialog with model description.""" model_class = self._model_name_to_class[self.model_name] message(message=model_class.__doc__, title='Model info') def _add_to_database_fired(self): """Add current results to database.""" if self.application is not None: self.application.add_current_state_to_database() def _action_finally(self): """Operations that need to be executed both in case of a success and a failure of the long-running action. """ self.model_update_suspended = False def _action_success(self, result): self._action_finally() self._fire_model_updated() def _action_failure(self, err): self._action_finally() if isinstance(err, PyannoValueError): errmsg = err.args[0] if 'Annotations' in errmsg: # raised when annotations are incompatible with the model error('Error: ' + errmsg) else: # re-raise exception if it has not been handled raise err def _action_on_model(self, message, method, args=None, kwargs=None, on_success=None, on_failure=None): """Call long running method on model. While the call is running, a window with a pulse progress bar is displayed. An error message is displayed if the call raises a PyannoValueError (raised when annotations are incompatible with the current model). """ if args is None: args = [] if kwargs is None: kwargs = {} if on_success is None: on_success = self._action_success if on_failure is None: on_failure = self._action_failure self.model_update_suspended = True call = LongRunningCall( parent=None, title='Calculating...', message=message, callable=method, args=args, kw=kwargs, on_success=on_success, on_failure=on_failure, ) call() def _ml_estimate_fired(self): """Run ML estimation of parameters.""" message = 'Computing maximum likelihood estimate' self._action_on_model(message, self.model.mle, args=[self.annotations]) def _map_estimate_fired(self): """Run ML estimation of parameters.""" message = 'Computing maximum a posteriori estimate' self._action_on_model(message, self.model.map, args=[self.annotations]) def _sample_posterior_success(self, samples): if (samples is not None and hasattr(self.model_view, 'plot_theta_samples')): self.model_view.plot_theta_samples(samples) self._action_finally() def _sample_posterior_over_accuracy_fired(self): """Sample the posterior of the parameters `theta`.""" message = 'Sampling from the posterior over accuracy' # open dialog asking for number of samples params = _SamplingParamsDialog() dialog_ui = params.edit_traits(kind='modal') if not dialog_ui.result: # user pressed "Cancel" return nsamples = params.nsamples self._action_on_model(message, self.model.sample_posterior_over_accuracy, args=[self.annotations, nsamples], kwargs={ 'burn_in_samples': params.burn_in_samples, 'thin_samples': params.thin_samples }, on_success=self._sample_posterior_success) def _estimate_labels_success(self, posterior): if posterior is not None: post_plot = PosteriorPlot(posterior=posterior, title='Posterior over classes') post_view = PosteriorView(posterior_plot=post_plot, annotations=self.annotations) post_view.edit_traits() self._action_finally() def _estimate_labels_fired(self): """Compute the posterior over annotations and show it in a new window""" message = 'Computing the posterior over classes' self._action_on_model(message, self.model.infer_labels, args=[self.annotations], on_success=self._estimate_labels_success) ### Views ################################################################ def traits_view(self): ## Model view # adjust sizes to display size if is_display_small(): # full view size w_view, h_view = 1024, 768 w_data_create_group = 350 w_data_info_group = 500 h_annotations_stats = 270 else: w_view, h_view = 1300, 850 w_data_create_group = 400 w_data_info_group = 700 h_annotations_stats = 330 model_create_group = (VGroup(HGroup( UItem(name='model_name', width=200), UItem(name='new_model', width=100), UItem(name='get_info_on_model', width=100, height=25), ), label='Create new model')) model_group = (VGroup( model_create_group, VGroup( Item('model_view', style='custom', show_label=False, width=400), label='Model view', ), ), ) ## Data view data_create_group = VGroup( #Label('Open annotation file:', width=800), HGroup( Item('annotations_file', style='simple', label='Open file:', width=w_data_create_group, height=25), UItem('new_annotations', height=25)), label='Load/create annotations', show_border=False, ) data_info_group = VGroup( Item( 'annotations_view', style='custom', show_label=False, visible_when='annotations_are_defined', width=w_data_info_group, ), Item('annotations_stats_view', style='custom', show_label=False, visible_when='annotations_are_defined', height=h_annotations_stats), label='Data view', ) data_group = (VGroup( data_create_group, data_info_group, ), ) ## (Model,Data) view model_data_group = ( VGroup( #Item('info_string', show_label=False, style='readonly'), Item('log_likelihood', label='Log likelihood', style='readonly'), HGroup( Item('ml_estimate', enabled_when='annotations_are_defined'), Item('map_estimate', enabled_when='annotations_are_defined'), Item('sample_posterior_over_accuracy', enabled_when='annotations_are_defined'), Item('estimate_labels', enabled_when='annotations_are_defined'), Spring(), Item('add_to_database', enabled_when='annotations_are_defined'), Item('open_database'), show_labels=False, ), label='Model-data view', )) ## Full view full_view = View( VGroup( HGroup(model_group, data_group), model_data_group, ), title='PyAnno - Models of data annotations by multiple curators', width=w_view, height=h_view, resizable=False) return full_view
class SmoothInputSpec(BaseInterfaceInputSpec): fmri_prep = ImageFile(desc='Preprocessed fMRI file') is_file_mandatory = Bool(default=True) output_directory = Directory(exists=True, )