def __init__(self, scope, dim_order='XYCZT', stack_settings=None, time_settings=None, channel_settings=None, backend=MemoryBackend): if stack_settings is None: stack_settings = scope.stackSettings assert(dim_order[:2] == 'XY') #first two dimensions must be XY (camera acquisition) # TODO more sanity checks on dim_order self.dim_order = dim_order self.scope = scope self.shape_x, self.shape_y = scope.frameWrangler.currentFrame.shape[:2] self.shape_z = stack_settings.GetSeqLength() self.shape_t = getattr(time_settings, 'num_timepoints', 1) self.shape_c = getattr(channel_settings, 'num_channels', 1) # note shape_t can be negative if we want to run until explicitly stopped self.n_frames = self.shape_z*self.shape_c*self.shape_t self.frame_num = 0 self.storage = backend(self.shape_x, self.shape_y, self.n_frames, dim_order=dim_order, shape=self.shape) #do any precomputation self._init_z(stack_settings) self._init_t(time_settings) self._init_c(channel_settings) self.on_single_frame = dispatch.Signal() #dispatched when a frame is ready self.on_series_end = dispatch.Signal() #dispatched when a sequence is complete
def __init__(self, testFrameSize=TEST_FRAME_SIZE, serverfilter=''): self.testData = (100 * np.random.rand(*testFrameSize)).astype('uint16') self.onFrame = dispatch.Signal(['frameData']) self.spoolProgress = dispatch.Signal(['percent']) self.mdh = MetaDataHandler.NestedClassMDHandler() self.serverfilter = serverfilter
def __init__(self, _cam, _ds = None, event_loop=None): #wx.EvtHandler.__init__(self) #self.timer = wx.Timer(self) #self.Bind(wx.EVT_TIMER, self.Notify) if event_loop is None: from PYME.ui import mytimer self._event_loop = mytimer else: self._event_loop = event_loop self.timer = self._event_loop.SingleTargetTimer(self.Notify) self.currentFrame = _ds self.cam = _cam self.aqOn = False #list of functions to call to see if we ought to wait on any hardware self.HardwareChecks = [] #should we start a new exposure on the next timer check? self.needExposureStart = False #did the buffer overflow? self.bufferOverflowed = False self.tLastFrame=0 self.tThisFrame=0 self.nFrames = 0 self.n_frames_in_group=0 self.tl=0 self.inNotify = False self._notify_lock = threading.Lock() #Signals ########################## # these allow other files to listen to key events happingin within the acquisiotn #new style signals - these will replace the WantFrameNotification etc ... #which are currently being kept for backwards compatibility self.onFrame = dispatch.Signal(['frameData']) #called each time a new frame appears in our buffer self.onFrameGroup = dispatch.Signal() #called on each new frame group (once per polling interval) - use for updateing GUIs etc. self.onStop = dispatch.Signal() self.onStart = dispatch.Signal() # should the thread which polls the camera still be running? self._poll_camera = True self._current_frame_lock = threading.Lock() self._poll_lock = threading.Lock() self._polling_interval = 0.01 # time between calls to poll the camera [s] self._poll_thread = threading.Thread(target=self._poll_loop) self._poll_thread.start()
def __init__(self, imageMdh=None, tq=None): self.analysisMDH = MetaDataHandler.CopyOnWriteMDHandler( imageMdh) #MetaDataHandler.NestedClassMDHandler(imageMdh) self.onImagesPushed = dispatch.Signal() self.onMetaDataChange = dispatch.Signal() self.tq = tq if self.tq is None: #try and find a task queue try: self._checkTQ() except: pass
def __init__(self, filename=None, visFr=None): self.filter = None self.mapping = None self.colourFilter = None self.events = None self.recipe = Recipe(execute_on_invalidation=True) self.recipe.recipe_executed.connect(self.Rebuild) self.selectedDataSourceKey = None self.filterKeys = { 'error_x': (0, 30), 'error_y': (0, 30), 'A': (5, 20000), 'sig': (95, 200) } self.blobSettings = BlobSettings() self.objects = None self.imageBounds = ImageBounds(0, 0, 0, 0) self.mdh = MetaDataHandler.NestedClassMDHandler() self.Triangles = None self.edb = None self.Quads = None self.GeneratedMeasures = {} self.QTGoalPixelSize = 5 self._extra_chan_num = 0 self.filesToClose = [] self.ev_mappings = {} #define a signal which a GUI can hook if the pipeline is rebuilt (i.e. the output changes) self.onRebuild = dispatch.Signal() #a cached list of our keys to be used to decide whether to fire a keys changed signal self._keys = None #define a signal which can be hooked if the pipeline keys have changed self.onKeysChanged = dispatch.Signal() self.ready = False #self.visFr = visFr if not filename is None: self.OpenFile(filename)
def __init__(self, *args, **kwargs): HasTraits.__init__(self, *args, **kwargs) self.namespace = {} # we open hdf files and don't necessarily read their contents into memory - these need to be closed when we # either delete the recipe, or clear the namespace self._open_input_files = [] self.recipe_changed = dispatch.Signal() self.recipe_executed = dispatch.Signal() self.recipe_failed = dispatch.Signal() self.failed = False self._dg_sig = None
def __init__(self, scope, pixels = 10, pixelsize=0.1, dwelltime = 1, background=0, avg=True, evtLog=False, sync=False, trigger=False, stop_on_complete=False, return_to_start=True): """ :param return_to_start: bool Flag to toggle returning home at the end of the scan. False leaves scope position as-is on scan completion. """ self.scope = scope #self.xpiezo = xpiezo #self.ypiezo = ypiezo self.trigger = trigger self.dwellTime = dwelltime self.background = background self.avg = avg self.pixels = pixels self.pixelsize = pixelsize self._stop_on_complete = stop_on_complete self._return_to_start = return_to_start if np.isscalar(pixelsize): self.pixelsize = np.array([pixelsize, pixelsize]) self.evtLog = evtLog self.sync = sync self._rlock = threading.Lock() self.running = False self._uuid = uuid.uuid4() self.on_stop = dispatch.Signal()
def __init__(self, key, getFcn=None, setFcn=None, needCamRestart=False): """Define a state-change handler for a give state key, based on supplied get and set functions which interact with the underlying hardware. This wrapper class serves two functions - a) allowing the get and set methods to be stored under a single dictionary key in the StateManager, and b) making sure a signal is fired when the state changes. Parameters ---------- key : string The hardware key - e.g. "Positioning.x", or "Lasers.405.Power". This will also be how the hardware state is recorder in the metadata. getFcn : function The function to call to get the value of the parameter. Should take one parameter which is the value to get setFcn : function The function to call to set the value of the parameter. Should take one parameter which is the value to set. Not providing a setFcn results in a read-only property. needCamRestart : bool Does this absolutely need a camera restart (e.g. we are changing which camera we are using). Will override other preferences. """ self.getValue = getFcn self.setFcn = setFcn self.key = key self.needCamRestart = needCamRestart self.onChange = dispatch.Signal()
def __init__(self, *args, **kwargs): try: self.orientation = kwargs.pop('orientation') except KeyError: self.orientation = wx.VERTICAL try: self.padding = kwargs.pop('padding') except KeyError: self.padding = 5 self._stretch_sizer = kwargs.pop('bottom_spacer', True) self._one_pane_active = kwargs.pop('single_active_pane', False) wx.Panel.__init__(self, *args, **kwargs) if self.orientation == wx.VERTICAL: self.sizerflags = wx.EXPAND #| wx.BOTTOM else: self.sizerflags = wx.EXPAND #| wx.RIGHT self.priorities = [] self.panes = [] self.sizer = wx.BoxSizer(self.orientation) self.SetSizer(self.sizer) self._in_fold1 = False self.fold_signal = dispatch.Signal() self.Bind(wx.EVT_SIZE, self.OnResize) self.Bind(EVT_CMD_PANEL_FOLD, self.OnResize)
def __init__(self): self.LIST_CHANGED_SIGNAL = dispatch.Signal() self._visibility_mask = [] self._names = {} self._rois = [] self._partial_ensemble_parameters = np.array([])
def __init__(self, *args, **kwargs): try: self.orientation = kwargs.pop('orientation') except KeyError: self.orientation = wx.VERTICAL try: self.padding = kwargs.pop('padding') except KeyError: self.padding = 5 wx.Panel.__init__(self, *args, **kwargs) if self.orientation == wx.VERTICAL: self.sizerflags = wx.EXPAND #| wx.BOTTOM else: self.sizerflags = wx.EXPAND #| wx.RIGHT self.priorities = [] self.panes = [] self.sizer = wx.BoxSizer(self.orientation) self.SetSizer(self.sizer) self.fold_signal = dispatch.Signal()
def __init__(self, scope): """Initialise our action manager Parameters ---------- scope : PYME.Acquire.microscope.microscope object The microscope. The function object to call for an action should be accessible within the scope namespace, and will be resolved by calling eval('scope.functionName') """ self.actionQueue = Queue.PriorityQueue() self.scope = weakref.ref(scope) #this will be assigned to a callback to indicate if the last task has completed self.isLastTaskDone = None self.paused = False self.currentTask = None self.onQueueChange = dispatch.Signal() self._timestamp = 0 self._monitoring = True self._monitor = threading.Thread(target=self._monitor_defunct) self._monitor.daemon = True self._monitor.start() self._lock = threading.Lock()
def __init__(self, scope, tile_dir, max_radius_um=100, tile_spacing=None, dwelltime=1, background=0, evtLog=False, trigger=False, base_tile_size=256, return_to_start=True): """ :param return_to_start: bool Flag to toggle returning home at the end of the scan. False leaves scope position as-is on scan completion. """ if tile_spacing is None: fs = np.array(scope.frameWrangler.currentFrame.shape[:2]) # calculate tile spacing such that there is ~30% overlap. tile_spacing = (1 / np.sqrt(2)) * fs * np.array( scope.GetPixelSize()) # take the pixel size to be the same or at least similar in both directions pixel_radius = int(max_radius_um / tile_spacing.mean()) logger.debug( 'Circular tiler target radius in units of (overlapped) FOVs: %d' % pixel_radius) pointScanner.CircularPointScanner.__init__( self, scope, pixel_radius, tile_spacing, dwelltime, background, False, evtLog, trigger=trigger, stop_on_complete=True, return_to_start=return_to_start) self._tiledir = tile_dir self._base_tile_size = base_tile_size self._flat = None #currently not used self._last_update_time = 0 self.on_stop = dispatch.Signal() self.progress = dispatch.Signal()
def __init__(self, _chans, _cam, _shutters, _ds=None): wx.EvtHandler.__init__(self) self.timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.Notify) self.chans = _chans #self.hwChans = _chans.hw #self.numHWChans = len(_chans.hw) #self.cols = _chans.cols self.dsa = _ds self.cam = _cam self.shutters = _shutters self.loopnuf = 0 self.aqOn = False #lists of functions to call on a new frame, and when the aquisition ends #self.WantFrameNotification = [] #self.WantStopNotification = [] #self.WantStartNotification = [] #list of functions to call to see if we ought to wait on any hardware self.HardwareChecks = [] #should we start a new exposure on the next timer check? self.needExposureStart = False self.tLastFrame = 0 self.tThisFrame = 0 self.nFrames = 0 self.tl = 0 self.inNotify = False self.zPos = 0 #will be needed to allow the display load to be minimised by, e.g. only updating display once per poll rather than once per frame #self.WantFrameGroupNotification = [] #Signals ########################## # these allow other files to listen to key events happingin within the acquisiotn #new style signals - these will replace the WantFrameNotification etc ... #which are currently being kept for backwards compatibility self.onFrame = dispatch.Signal( ['frameData']) #called each time a new frame appears in our buffer self.onFrameGroup = dispatch.Signal( ) #called on each new frame group (once per polling interval) - use for updateing GUIs etc. self.onStop = dispatch.Signal() self.onStart = dispatch.Signal()
def __init__(self): self.analysisMDH = MetaDataHandler.NestedClassMDHandler() self.onMetadataChanged = dispatch.Signal() self.propagateToAcquisisitonMetadata = False MetaDataHandler.provideStartMetadata.append(self.genStartMetadata)
def __init__(self, scope, handlers={}): self._stateHandlers = {} self._cachedStates = {} self._stateHandlers.update(handlers) self.scope = weakref.ref(scope) self.stateChanged = dispatch.Signal()
def __init__(self, filename, frameSource, protocol=p.NullProtocol, guiUpdateCallback=None, fakeCamCycleTime=None, maxFrames=p.maxint, **kwargs): """Create a new spooler. Parameters ---------- scope : PYME.Acquire.microscope.microscope object The microscope providing the data filename : string The file into which to spool frameSource : dispatch.Signal object A source of frames we can subscribe to. It should implement a "connect" method allowing us to register a callback and then call the callback with the frame data in a "frameData" kwarg. protocol : PYME.Acquire.protocol.TaskListProtocol object The acquisition protocol guiUpdateCallback : function a function to call when the spooling GUI needs updating """ global timeFcn #self.scope = scope self.filename = filename self.frameSource = frameSource self.guiUpdateCallback = guiUpdateCallback self.protocol = protocol self.maxFrames = maxFrames stack_settings = kwargs.get('stack_settings', None) if stack_settings: # only record stack settings if provided (letting protocol fall through to global stack settings, # if not provided / None) self.stack_settings = stack_settings self.onSpoolStop = dispatch.Signal() #if we've got a fake camera - the cycle time will be wrong - fake our time sig to make up for this #if scope.cam.__class__.__name__ == 'FakeCamera': # timeFcn = self.fakeTime self._last_gui_update = 0 self.spoolOn = False self.imNum = 0 self.spool_complete = False self._spooler_uuid = uuid.uuid4() if not fakeCamCycleTime is None: self.fakeCamCycleTime = fakeCamCycleTime timeFcn = self.fakeTime
def __init__(self, scope, tile_dir, n_tiles=10, tile_spacing=None, dwelltime=1, background=0, evtLog=False, trigger=False, base_tile_size=256, return_to_start=True, backend='file'): """ :param return_to_start: bool Flag to toggle returning home at the end of the scan. False leaves scope position as-is on scan completion. """ if tile_spacing is None: fs = np.array(scope.frameWrangler.currentFrame.shape[:2]) #calculate tile spacing such that there is 20% overlap. tile_spacing = 0.8 * fs * np.array(scope.GetPixelSize()) pointScanner.PointScanner.__init__(self, scope=scope, pixels=n_tiles, pixelsize=tile_spacing, dwelltime=dwelltime, background=background, avg=False, evtLog=evtLog, trigger=trigger, stop_on_complete=True, return_to_start=return_to_start) self._tiledir = tile_dir self._base_tile_size = base_tile_size self._flat = None #currently not used self._last_update_time = 0 self._backend = backend self.on_stop = dispatch.Signal() self.progress = dispatch.Signal()
def __init__(self, use_shaders=False): self._new_layers = PYME.config.get('VisGUI-new_layers', False) self.viewMode = 'points' #one of points, triangles, quads, or voronoi #self.colData = 't' self.pointDisplaySettings = pointSettingsPanel.PointDisplaySettings() self.pointDisplaySettings.on_trait_change(self.RefreshView) self.quadTreeSettings = quadTreeSettings.QuadTreeSettings() self.quadTreeSettings.on_trait_change(self.RefreshView) self.pipeline.blobSettings.on_trait_change(self.RefreshView) self.pipeline.onRebuild.connect(self.RefreshView) #initialize the gl canvas if isinstance(self, wx.Window): win = self else: win = self.dsviewer gl_pan = wx.Panel(win) sizer = wx.BoxSizer(wx.VERTICAL) if not use_shaders: self.glCanvas = gl_render.LMGLCanvas(gl_pan) else: from PYME.LMVis.gl_render3D_shaders import LMGLShaderCanvas, LegacyGLCanvas if self._new_layers: #use stripped down version self.glCanvas = LMGLShaderCanvas(gl_pan) else: self.glCanvas = LegacyGLCanvas(gl_pan) sizer.Add(self.create_tool_bar(gl_pan), 0, wx.EXPAND, 0) sizer.Add(self.glCanvas, 5, wx.EXPAND, 0) gl_pan.SetSizerAndFit(sizer) win.AddPage(page=gl_pan, caption='View')#, select=True) #self.glCanvas.setCMap(pylab.cm.gist_rainbow) #pylab.cm.hot #self.rec_gui = recipeGui. #win.AddPage(page=self.glCanvas, caption='View')#, select=True) self.refv = False self._legacy_layer = None self.layer_added = dispatch.Signal() renderers.renderMetadataProviders.append(self.SaveMetadata) self.use_shaders = use_shaders wx.CallLater(100, self.OnIdle)
def __init__(self, scope): self.scope = scope self.stackSettings = scope.stackSettings self.off = 0 self.sc = 100 self.sqrt = False self.frameNum = 0 #self.ds = scope.frameWrangler.currentFrame self.shape_x, self.shape_y = scope.frameWrangler.currentFrame.shape[:2] self.running = False #legacy signalling - don't use in new code. #self.WantFrameNotification = [] #self.WantTickNotification = [] #These signals should instead of the notification lists above self.onStack = dispatch.Signal() #dispatched on completion of a stack self.onSingleFrame = dispatch.Signal() #dispatched when a frame is ready
def __init__(self, pipeline, method='wireframe', dsname='', context=None, **kwargs): EngineLayer.__init__(self, context=context, **kwargs) self._pipeline = pipeline self.engine = None self.cmap = 'gist_rainbow' self.x_key = 'x' # TODO - make these traits? self.y_key = 'y' self.z_key = 'z' self.xn_key = 'xn' self.yn_key = 'yn' self.zn_key = 'zn' self._bbox = None # define a signal so that people can be notified when we are updated (currently used to force a redraw when # parameters change) self.on_update = dispatch.Signal() # define responses to changes in various traits self.on_trait_change(self._update, 'vertexColour') self.on_trait_change(lambda: self.on_update.send(self), 'visible') self.on_trait_change( self.update, 'cmap, clim, alpha, dsname, normal_mode, display_normals, normal_scaling' ) self.on_trait_change(self._set_method, 'method') # update any of our traits which were passed as command line arguments self.set(**kwargs) # update datasource and method self.dsname = dsname if self.method == method: #make sure we still call _set_method even if we start with the default method self._set_method() else: self.method = method # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update # ourselves if not self._pipeline is None: try: self._pipeline.onRebuild.connect(self.update) except AttributeError: pass
def __init__(self, datasource, xp=0, yp=0, zp=0, aspect=1): self.WantChangeNotification = [] # MyWeakSet() #[] self.Chans = [] self.Gains = [] self.Offs = [] self.cmaps = [] self.names = [] self.show = [] self._xp = 0 self._yp = 0 self._zp = 0 self._tp = 0 self.maximumProjection = False self.colourMax = False self.cmax_offset = 0.0 self.cmax_scale = 1.0 self._complexMode = 'coloured' self.inOnChange = False self.syncedWith = [] self.SetDataStack(datasource) self.SetAspect(aspect) self.ResetSelection() self.orientation = self.UPRIGHT self.slice = self.SLICE_XY self.scale = 0 self.leftButtonAction = self.ACTION_POSITION self.selectionMode = self.SELECTION_RECTANGLE self.selectionWidth = 1 self.showSelection = False #signals (currently just for selection end # this lets people know that we've made a selection. Used to allow modification of the selection by some filter # e.g. using active contours in the annotation module self.on_selection_end = dispatch.Signal() self.overlays = []
def __init__(self, pipeline, method='points', dsname='', context=None, **kwargs): EngineLayer.__init__(self, context=context, **kwargs) self._pipeline = pipeline self.engine = None self.cmap = 'gist_rainbow' self.x_key = 'x' #TODO - make these traits? self.y_key = 'y' self.z_key = 'z' self.xn_key = 'xn' self.yn_key = 'yn' self.zn_key = 'zn' self._bbox = None # define a signal so that people can be notified when we are updated (currently used to force a redraw when # parameters change) self.on_update = dispatch.Signal() # define responses to changes in various traits self.on_trait_change(self._update, 'vertexColour') self.on_trait_change(lambda: self.on_update.send(self), 'visible') self.on_trait_change(self.update, 'cmap, clim, alpha, dsname, point_size') self.on_trait_change(self._set_method, 'method') # update any of our traits which were passed as command line arguments self.set(**kwargs) # update datasource name and method #logger.debug('Setting dsname and method') self.dsname = dsname self.method = method self._set_method() # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update # ourselves if not self._pipeline is None: self._pipeline.onRebuild.connect(self.update)
def __init__(self, pipeline, method='image', dsname='', display_opts=None, context=None, **kwargs): EngineLayer.__init__(self, context=context, **kwargs) self._pipeline = pipeline self.engine = None self.cmap = 'gray' self._bbox = None self._do = display_opts #a dh5view display_options instance - if provided, this over-rides the the clim, cmap properties self._im_key = None # define a signal so that people can be notified when we are updated (currently used to force a redraw when # parameters change) self.on_update = dispatch.Signal() # define responses to changes in various traits #self.on_trait_change(self._update, 'vertexColour') self.on_trait_change(lambda: self.on_update.send(self), 'visible') self.on_trait_change(self.update, 'cmap, clim, alpha, dsname') self.on_trait_change(self._set_method, 'method') # update any of our traits which were passed as command line arguments self.set(**kwargs) # update datasource and method self.dsname = dsname if self.method == method: #make sure we still call _set_method even if we start with the default method self._set_method() else: self.method = method # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update # ourselves if (not self._pipeline is None) and hasattr(pipeline, 'onRebuild'): self._pipeline.onRebuild.connect(self.update)
def __init__(self, spool_controller, posting_thread_queue_size=5): """ Parameters ---------- posting_thread_queue_size : int, optional sets the size of a queue to hold rule posting threads to ensure they have time to execute, by default 5. .. seealso:: modules :py:mod:`PYME.cluster.rules` """ import queue OrderedDict.__init__(self) self.active = True self._spool_controller = spool_controller self.posting_thread_queue = queue.Queue(posting_thread_queue_size) self._updated = dispatch.Signal() self._updated.connect(self.update) self['default'] = RuleChain() self._spool_controller.onSpoolStart.connect(self.on_spool_start) self._spool_controller.onSpoolStop.connect(self.on_spool_stop)
def __init__(self): #self.image = image self.onFrame = dispatch.Signal(['frameData']) self.spoolProgress = dispatch.Signal(['percent'])
def __init__(self, parent, show_lut=True, display_mode='2D', view=None): print("New Canvas") attribute_list = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_STENCIL_SIZE, 8, wx.glcanvas.WX_GL_DOUBLEBUFFER ] self._num_antialias_samples = int( config.get('VisGUI-antialias_samples', 4)) if self._num_antialias_samples > 0: attribute_list.extend([ wx.glcanvas.WX_GL_SAMPLE_BUFFERS, 1, wx.glcanvas.WX_GL_SAMPLES, self._num_antialias_samples ]) GLCanvas.__init__(self, parent, -1, attribList=attribute_list) self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_MOUSEWHEEL, self.OnWheel) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.Bind(wx.EVT_MIDDLE_DOWN, self.OnMiddleDown) self.Bind(wx.EVT_MIDDLE_UP, self.OnMiddleUp) self.Bind(wx.EVT_RIGHT_DOWN, self.OnMiddleDown) self.Bind(wx.EVT_RIGHT_UP, self.OnMiddleUp) self.Bind(wx.EVT_MOTION, self.OnMouseMove) self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPress) # wx.EVT_MOVE(self, self.OnMove) try: self.gl_context = wx.glcanvas.GLContext(self) except: logger.exception( 'Error creating OpenGL context, try modifying the number of anti-aliasing samples using the "VisGUI-antialias_samples" config setting (0 to disable antialiasing)' ) raise self.displayMode = display_mode # 3DPersp' #one of 3DPersp, 3DOrtho, 2D self.parent = parent self._scaleBarLength = 1000 self.clear_colour = [0, 0, 0, 1.0] self.LUTDraw = show_lut self.zmin = -10 self.zmax = 10 self.angup = 0 self.angright = 0 if view is None: self.view = views.View() else: self.view = view self.sx = 100 self.sy = 100 self.zc_o = 0 self.stereo = False self.eye_dist = .01 self.dragging = False self.panning = False self.selectionSettings = SelectionSettings() self.selectionDragging = False self.layers = [] self.overlays = [] self.underlays = [ ] #draw these before data (assuming depth-testing is disabled) self.wantViewChangeNotification = WeakSet() self.pointSelectionCallbacks = [] self.on_screen = True self.view_port_size = (self.Size[0], self.Size[1]) self._old_bbox = None self.layer_added = dispatch.Signal()
def __init__(self, parent, filterKeys, dataSource=None): """ Parameters ---------- parent : wx.Window filterKeys : dict Dictionary keys dataSource : function function to call to get the current data source """ wx.Panel.__init__(self, parent) self.filterKeys = filterKeys self._dataSource = dataSource self.on_filter_changed = dispatch.Signal() #GUI stuff vsizer = wx.BoxSizer(wx.VERTICAL) self.lFiltKeys = wx.ListCtrl( self, -1, style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.SUNKEN_BORDER, size=(-1, 25 * (max(len(self.filterKeys.keys()) + 1, 5)))) self.lFiltKeys.InsertColumn(0, 'Key') self.lFiltKeys.InsertColumn(1, 'Min') self.lFiltKeys.InsertColumn(2, 'Max') self.populate() self.lFiltKeys.SetColumnWidth(0, wx.LIST_AUTOSIZE) self.lFiltKeys.SetColumnWidth(1, wx.LIST_AUTOSIZE) self.lFiltKeys.SetColumnWidth(2, wx.LIST_AUTOSIZE) # only do this part the first time so the events are only bound once if not hasattr(self, "ID_FILT_ADD"): self.ID_FILT_ADD = wx.NewId() self.ID_FILT_DELETE = wx.NewId() self.ID_FILT_EDIT = wx.NewId() self.Bind(wx.EVT_MENU, self.OnFilterAdd, id=self.ID_FILT_ADD) self.Bind(wx.EVT_MENU, self.OnFilterDelete, id=self.ID_FILT_DELETE) self.Bind(wx.EVT_MENU, self.OnFilterEdit, id=self.ID_FILT_EDIT) # for wxMSW self.lFiltKeys.Bind(wx.EVT_COMMAND_RIGHT_CLICK, self.OnFilterListRightClick) # for wxGTK self.lFiltKeys.Bind(wx.EVT_RIGHT_UP, self.OnFilterListRightClick) self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnFilterItemSelected) self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnFilterItemDeselected) self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnFilterEdit) vsizer.Add(self.lFiltKeys, 1, wx.ALL | wx.EXPAND, 0) #self.stNumFiltered = wx.StaticText(self, -1, '') #vsizer.Add(self.stNumFiltered, 0, wx.ALL | wx.EXPAND, 2) self.SetSizerAndFit(vsizer)
def __init__(self, scope, defDir=genHDFDataFilepath(), defSeries='%(day)d_%(month)d_series'): """Initialise the spooling controller. Parameters ---------- scope : microscope instance The currently active microscope class (see microscope.py) defDir : string pattern The default directory to save data to. Any keys of the form `%(<key>)` will be substituted using the values defined in `PYME.fileUtils.nameUtils.dateDict` defSeries : string pattern This specifies a pattern for file naming. Keys will be substituted as for `defDir` """ self.scope = scope if int(sys.version[0]) < 3: #default to Queue for Py2 self.spoolType = 'Queue' else: #else default to file self.spoolType = 'File' #dtn = datetime.datetime.now() #dateDict = {'username' : win32api.GetUserName(), 'day' : dtn.day, 'month' : dtn.month, 'year':dtn.year} self._base_dir = nameUtils.get_local_data_directory() self._dirname = os.sep.join([self._base_dir, ] + nameUtils.get_spool_subdir()) self._cluster_dirname = self.get_cluster_dirname(self._dirname) self.seriesStub = defSeries % nameUtils.dateDict self.seriesCounter = 0 self._series_name = None self.protocol = prot.NullProtocol self.protocolZ = prot.NullZProtocol self.onSpoolProgress = dispatch.Signal() self.onSpoolStart = dispatch.Signal() self.onSpoolStop = dispatch.Signal() self._analysis_launchers = queue.Queue(3) self._status_changed_condition = threading.Condition() #settings which were managed by GUI self.hdf_compression_level = 2 # zlib compression level that pytables should use (spool to file and queue) self.z_stepped = False # z-step during acquisition self.z_dwell = 100 # time to spend at each z level (if z_stepped == True) self.cluster_h5 = False # spool to h5 on cluster (cluster of one) self.pzf_compression_settings=HTTPSpooler.defaultCompSettings # only for cluster spooling #check to see if we have a cluster self._N_data_servers = len(hybrid_ns.getNS('_pyme-http').get_advertised_services()) if self._N_data_servers > 0: # switch to cluster as spool method if available. self.SetSpoolMethod('Cluster') if self._N_data_servers == 1: self.cluster_h5 = True # we have a cluster of one