def __init__(self, width, height): logger = log.get_logger(null=True) # We just use a ginga widget to implement the readout readout = Viewers.CanvasView(logger=logger) readout.set_desired_size(width, height) bg = colors.lookup_color('#202030') readout.set_bg(*bg) self.viewer = readout self.readout = Widgets.wrap(readout.get_widget()) self.readout.resize(width, height) canvas = readout.get_canvas() Text = canvas.get_draw_class('text') xoff, yoff = 4, 4 self.text_obj = Text(xoff, height-yoff, text='', color='lightgreen', fontsize=14, coord='canvas') canvas.add(self.text_obj, redraw=False) self.maxx = 0 self.maxy = 0 self.maxv = 0 self.fitsimage = None
def main(options, args): logger = log.get_logger("example2", options=options) ev_quit = threading.Event() thread_pool = Task.ThreadPool(options.numthreads, logger, ev_quit=ev_quit) thread_pool.startall() try: factory = ViewerFactory(logger, options.basedir, thread_pool) js_path = os.path.dirname(js.__file__) # run the app app = tornado.web.Application([ (r"/js/(.*\.js)", tornado.web.StaticFileHandler, {"path": js_path}), (r"/viewer", FileHandler, dict(name='Ginga', url='/viewer', factory=factory)), ("/viewer/socket", FitsViewer, dict(name='Ginga', factory=factory)), ], factory=factory, logger=logger) app.listen(options.port, options.host) print("ginga web now running at http://" + options.host + ":" + \ str(options.port) + "/viewer") tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: print("Interrupted!") finally: ev_quit.set() thread_pool.stopall()
def new_client(self, dc=None, canvas=None): from ...qt import get_qapp get_qapp() dc = dc or self.collect l = log.get_logger(name='ginga', log_stderr=True) canvas = ImageViewCanvas(l, render='widget') return GingaClient(dc, canvas)
def main(options, args): #QtGui.QApplication.setGraphicsSystem('raster') app = QtGui.QApplication(args) logger = log.get_logger("example2", options=options) # Check whether user wants to use OpenCv if options.opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("failed to set OpenCv preference: %s" % (str(e))) # Check whether user wants to use OpenCL elif options.opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("failed to set OpenCL preference: %s" % (str(e))) w = FitsViewer(logger) w.resize(524, 540) w.show() app.setActiveWindow(w) w.raise_() w.activateWindow() if len(args) > 0: w.load_file(args[0]) app.exec_()
def main(options, args): logger = log.get_logger("example2", options=options) if options.toolkit is None: logger.error("Please choose a GUI toolkit with -t option") # decide our toolkit, then import ginga_toolkit.use(options.toolkit) # event for synchronizing exit of all threads ev_quit = threading.Event() gv = GingaVision(logger, ev_quit, options) gv.top.resize(670, 540) gv.top.show() gv.top.raise_() # start video capture thread if len(args) > 0: filename = args[0] else: # default video input device filename = 0 gv.main.nongui_do(gv.capture_video, filename) gv.main.mainloop() logger.info("program terminating...") sys.exit(0)
def main(options, args): logger = log.get_logger("ginga", options=options) # create a new plot with default tools, using figure fig = figure(x_range=[0,600], y_range=[0,600], plot_width=600, plot_height=600, toolbar_location=None) viewer = ib.CanvasView(logger) viewer.set_figure(fig) def load_file(path): image = AstroImage(logger) image.load_file(path) viewer.set_image(image) def load_file_cb(attr_name, old_val, new_val): #print(attr_name, old_val, new_val) load_file(new_val) # add a entry widget and configure with the call back dstdir = options.indir path_w = TextInput(value=dstdir, title="File:") path_w.on_change('value', load_file_cb) if len(args) > 0: load_file(args[0]) # put the path widget and viewer in a layout and add to the document curdoc().add_root(vplot(fig, path_w))
def main(options, args): # Create top level logger. logger = log.get_logger(name='qcheck', options=options) if options.input_filename: # This section is for reading an Excel file that has the usual # sheets in it (targets, envcfg, etc.) # Append any directory path supplied in options.input_filename # onto the end of the options.input_dir value. input_dir = os.path.join(options.input_dir, os.path.dirname(options.input_filename)) # Parse the input filename so we can get the proposal name. input_filename = os.path.basename(options.input_filename) propname, ext = input_filename.split('.') if ext in filetypes.QueueFile.excel_ext: propdict = {} key = propname.upper() propdict[key] = entity.Program(key, hours=0, category='') progFile = filetypes.ProgramFile(input_dir, logger, propname, propdict) else: logger.error("File extension '%s' is not a valid file type. Must be one of %s." % (ext, filetypes.QueueFile.excel_ext)) sys.exit(1) else: # This section is for reading a directory that contains CSV # files, i.e., targets.csv, inscfg.csv, etc. dirname = os.path.dirname(options.input_dir) propname = os.path.basename(options.input_dir) propdict = {} key = propname.upper() propdict[key] = entity.Program(key, hours=0, category='') progFile = filetypes.ProgramFile(dirname, logger, propname, propdict, file_ext='csv') logger.info('Warning count is %d' % progFile.warn_count) logger.info('Error count is %d' % progFile.error_count)
def make_server(logger=None, basedir='.', numthreads=5, host='localhost', port=9909, use_opencv=False): if logger is None: logger = log.get_logger("ipg", null=True) ev_quit = threading.Event() if use_opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("Error using opencv: %s" % str(e)) thread_pool = Task.ThreadPool(numthreads, logger, ev_quit=ev_quit) base_url = "http://%s:%d/app" % (host, port) app = Widgets.Application(logger=logger, base_url=base_url, host=host, port=port) factory = ViewerFactory(logger, basedir, app, thread_pool) server = WebServer(app, thread_pool, factory, host=host, port=port) return server
def main(options, args): logger = log.get_logger("example2", options=options) if options.toolkit is None: logger.error("Please choose a GUI toolkit with -t option") # decide our toolkit, then import ginga_toolkit.use(options.toolkit) viewer = FitsViewer(logger) viewer.top.resize(700, 540) if len(args) > 0: viewer.load_file(args[0]) viewer.top.show() viewer.top.raise_() try: app = viewer.top.get_app() # TODO: unify these if hasattr(app, "start"): app.start() else: while True: app.process_events() except KeyboardInterrupt: print("Terminating viewer...") if viewer.top is not None: viewer.top.close()
def main(options, args): logger = log.get_logger("example2", options=options) if options.toolkit is None: logger.error("Please choose a GUI toolkit with -t option") # decide our toolkit, then import ginga_toolkit.use(options.toolkit) viewer = FitsViewer(logger) viewer.top.resize(700, 540) if len(args) > 0: viewer.load_file(viewer.viewer1, args[0]) viewer.top.show() viewer.top.raise_() try: viewer.app.mainloop() except KeyboardInterrupt: print("Terminating viewer...") if viewer.top is not None: viewer.top.close()
def main(options, args): logger = log.get_logger("example2", options=options) # Check whether user wants to use OpenCv if options.opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("failed to set OpenCv preference: %s" % (str(e))) # Check whether user wants to use OpenCL elif options.opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("failed to set OpenCL preference: %s" % (str(e))) fv = FitsViewer(logger) root = fv.get_widget() root.show_all() if len(args) > 0: fv.load_file(args[0]) gtk.main()
def __init__(self, *objects): CanvasObjectBase.__init__(self) CompoundMixin.__init__(self) self.objects = list(objects) self.logger = get_logger('foo', log_stderr=True, level=10) self.kind = 'compound' self.editable = False
def new_client(self, dc=None, canvas=None): from glue.utils.qt import get_qapp get_qapp() dc = dc or self.collect l = log.get_logger(name="ginga", log_stderr=True) canvas = ImageViewCanvas(l, render="widget") return GingaClient(dc, canvas)
def __init__(self, *objects, **kwdargs): CanvasObjectBase.__init__(self, **kwdargs) CompoundMixin.__init__(self) self.objects = list(objects) self.logger = get_logger("foo", log_stderr=True, level=10) self.kind = "compound" self.editable = False
def main(options, args): #logger = log.get_logger("ginga", options=options) logger = log.get_logger("ginga", level=20, log_file="/tmp/ginga.log") #TOOLS = "pan,wheel_zoom,box_select,tap" TOOLS = "box_select" # create a new plot with default tools, using figure fig = figure(x_range=[0, 600], y_range=[0, 600], plot_width=600, plot_height=600, tools=TOOLS) viewer = ib.CanvasView(logger) viewer.set_figure(fig) bd = viewer.get_bindings() bd.enable_all(True) ## box_select_tool = fig.select(dict(type=BoxSelectTool)) ## box_select_tool.select_every_mousemove = True #tap_tool = fig.select_one(TapTool).renderers = [cr] # open a session to keep our local document in sync with server #session = push_session(curdoc()) #curdoc().add_periodic_callback(update, 50) def load_file(path): image = load_data(path, logger=logger) viewer.set_image(image) def load_file_cb(attr_name, old_val, new_val): #print(attr_name, old_val, new_val) load_file(new_val) def zoom_ctl_cb(attr_name, old_val, new_val): if new_val >= 0: new_val += 2 viewer.zoom_to(int(new_val)) scale = viewer.get_scale() logger.info("%f" % scale) viewer.onscreen_message("%f" % (scale), delay=0.3) # add a entry widget and configure with the call back #dstdir = options.indir dstdir = "" path_w = TextInput(value=dstdir, title="File:") path_w.on_change('value', load_file_cb) slide = Slider(start=-20, end=20, step=1, value=1) slide.on_change('value', zoom_ctl_cb) layout = column(fig, path_w, slide) curdoc().add_root(layout) if len(args) > 0: load_file(args[0])
def __init__(self, logger=None): self.timer_lock = threading.RLock() self.timer_cnt = 0 self.timer = {} self.base_interval_msec = default_timer_interval_msec self._timeout = None if logger is None: # substitute a null logger if user didn't provide one logger = log.get_logger(name='timerfactory', null=True, level=50) self.logger = logger
def main(options, args): logger = log.get_logger("example2", options=options) fv = FitsViewer(logger) top = fv.get_widget() if len(args) > 0: fv.load_file(args[0]) top.mainloop()
def main(options, args): # Create top level logger. logger = log.get_logger(name='t_schedule', options=options) sdl = StandAlone_Scheduler(logger, options.input_dir, options.host, options.port) sdl.init_db() #sdl.schedule_files() #sdl.schedule_db() sys.exit(0)
def __init__(self, host='localhost', port=9909, logger=None, numthreads=5): self.tornado_app = None self.viewers = {} self.host = host self.port = port if logger is None: logger = log.get_logger("nbinteract_server", null=True) self.logger = logger self.thread_pool = Task.ThreadPool(numthreads, logger) self.app = Widgets.Application(logger=self.logger, base_url=self.base_url)
def __init__(self, session, parent=None): self.logger = log.get_logger( name="ginga", level=20, null=True, # uncomment for debugging # log_stderr=True ) self.canvas = ImageViewCanvas(self.logger, render="widget") # prevent widget from grabbing focus try: self.canvas.set_enter_focus(False) except AttributeError: self.canvas.set_follow_focus(False) # enable interactive features bindings = self.canvas.get_bindings() bindings.enable_all(True) self.canvas.add_callback("none-move", self.motion_readout) self.canvas.add_callback("draw-event", self._apply_roi_cb) self.canvas.add_callback("draw-down", self._clear_roi_cb) self.canvas.enable_draw(False) self.canvas.enable_autozoom("off") self.canvas.set_zoom_algorithm("rate") self.canvas.set_zoomrate(1.4) bm = self.canvas.get_bindmap() bm.add_callback("mode-set", self.mode_set_cb) self.mode_w = None self.mode_actns = {} # Create settings and set defaults settings = self.canvas.get_settings() self.settings = settings settings.getSetting("cuts").add_callback("set", self.cut_levels_cb) settings.set(autozoom="off", autocuts="override", autocenter="override") # make color bar, with color maps shared from ginga canvas self.colorbar = ColorBar.ColorBar(self.logger) rgbmap = self.canvas.get_rgbmap() rgbmap.add_callback("changed", self.rgbmap_cb, self.canvas) self.colorbar.set_rgbmap(rgbmap) # make coordinates/value readout self.readout = Readout.Readout(-1, -1) self.roi_tag = None super(GingaWidget, self).__init__(session, parent)
def main(options, args): #QtGui.QApplication.setGraphicsSystem('raster') app = QtGui.QApplication(args) logger = log.get_logger(name="example1", options=options) viewer = FitsViewer(logger) viewer.resize(524, 540) viewer.show() app.setActiveWindow(viewer) if len(args) > 0: viewer.load_file(args[0]) app.exec_()
def main(options, args): logger = log.get_logger("ipg", options=options) server = make_server(logger=logger, basedir=options.basedir, numthreads=options.numthreads, host=options.host, port=options.port, use_opencv=options.use_opencv) try: server.start(use_thread=False) except KeyboardInterrupt: logger.info("Interrupted!") server.stop() logger.info("Server terminating...")
def main(options, args): app = QtGui.QApplication(args) logger = log.get_logger(name="example2", options=options) w = FitsViewer(logger) w.resize(524, 540) w.show() app.setActiveWindow(w) w.raise_() w.activateWindow() if len(args) > 0: w.load_file(args[0]) app.exec_()
def main(options, args): QtGui.QApplication.setGraphicsSystem("raster") app = QtGui.QApplication(args) app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()")) logger = log.get_logger(name="example1", options=options) viewer = FitsViewer(logger) viewer.resize(524, 540) viewer.show() app.setActiveWindow(viewer) if len(args) > 0: viewer.load_file(args[0]) app.exec_()
def main(options, args): logger = log.get_logger("example2", options=options) if options.toolkit is None: logger.error("Please choose a GUI toolkit with -t option") # decide our toolkit, then import ginga_toolkit.use(options.toolkit) if options.use_opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("Error using OpenCv: %s" % str(e)) if options.use_opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("Error using OpenCL: %s" % str(e)) viewer = FitsViewer(logger) if options.renderer is not None: render_class = render.get_render_class(options.renderer) viewer.fitsimage.set_renderer(render_class(viewer.fitsimage)) viewer.top.resize(700, 540) if len(args) > 0: viewer.load_file(args[0]) viewer.top.show() viewer.top.raise_() try: app = viewer.top.get_app() app.mainloop() except KeyboardInterrupt: print("Terminating viewer...") if viewer.top is not None: viewer.top.close()
def __init__(self, obj, host='localhost', port=9000, ev_quit=None, logger=None): super(RemoteServer, self).__init__() self.robj = obj # What port to listen for requests self.port = port # If blank, listens on all interfaces self.host = host if logger is None: logger = log.get_logger(null=True) self.logger = logger if ev_quit is None: ev_quit = threading.Event() self.ev_quit = ev_quit
def main(options, args): logger = log.get_logger("example2", options=options) if options.use_opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("Error using OpenCv: %s" % str(e)) if options.use_opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("Error using OpenCL: %s" % str(e)) base_url = "http://%s:%d/app" % (options.host, options.port) # establish our widget application app = Widgets.Application(logger=logger, host=options.host, port=options.port) # create top level window window = app.make_window("Ginga web example2") # our own viewer object, customized with methods (see above) viewer = FitsViewer(logger, window) #server.add_callback('shutdown', viewer.quit) #window.resize(700, 540) if len(args) > 0: viewer.load_file(args[0]) #window.show() #window.raise_() try: app.start() except KeyboardInterrupt: logger.info("Terminating viewer...") window.close()
def __init__(self, session, parent=None): self.logger = log.get_logger(name='ginga', level=20, null=True, # uncomment for debugging #log_stderr=True ) self.canvas = ImageViewCanvas(self.logger, render='widget') # prevent widget from grabbing focus self.canvas.set_follow_focus(False) # enable interactive features bindings = self.canvas.get_bindings() bindings.enable_all(True) self.canvas.add_callback('none-move', self.motion_readout) self.canvas.add_callback('draw-event', self._apply_roi_cb) self.canvas.add_callback('draw-down', self._clear_roi_cb) self.canvas.enable_draw(False) self.canvas.enable_autozoom('off') self.canvas.set_zoom_algorithm('rate') self.canvas.set_zoomrate(1.4) bm = self.canvas.get_bindmap() bm.add_callback('mode-set', self.mode_set_cb) self.mode_w = None self.mode_actns = {} # Create settings and set defaults settings = self.canvas.get_settings() self.settings = settings settings.getSetting('cuts').add_callback('set', self.cut_levels_cb) settings.set(autozoom='off', autocuts='override', autocenter='override') # make color bar, with color maps shared from ginga canvas self.colorbar = ColorBar.ColorBar(self.logger) rgbmap = self.canvas.get_rgbmap() rgbmap.add_callback('changed', self.rgbmap_cb, self.canvas) self.colorbar.set_rgbmap(rgbmap) # make coordinates/value readout self.readout = Readout.Readout(-1, -1) self.roi_tag = None super(GingaWidget, self).__init__(session, parent)
def main(options, args): logger = log.get_logger("ginga", options=options) TOOLS = "pan,wheel_zoom,box_select,tap" # create a new plot with default tools, using figure fig = figure(x_range=[0,600], y_range=[0,600], plot_width=600, plot_height=600, tools=TOOLS) viewer = ib.CanvasView(logger) viewer.set_figure(fig) ## box_select_tool = fig.select(dict(type=BoxSelectTool)) ## box_select_tool.select_every_mousemove = True #tap_tool = fig.select_one(TapTool).renderers = [cr] # open a session to keep our local document in sync with server session = push_session(curdoc()) #curdoc().add_periodic_callback(update, 50) def load_file(path): image = AstroImage(logger) image.load_file(path) viewer.set_image(image) def load_file_cb(attr_name, old_val, new_val): #print(attr_name, old_val, new_val) load_file(new_val) # add a entry widget and configure with the call back dstdir = options.indir path_w = TextInput(value=dstdir, title="File:") path_w.on_change('value', load_file_cb) curdoc().add_root(vplot(fig, path_w)) if len(args) > 0: load_file(args[0]) # open the document in a browser session.show() # run forever session.loop_until_closed()
def main(options, args): logger = log.get_logger(name="mosaic", options=options) img_mosaic = mosaic(logger, args, fov_deg=options.fov) if options.outfile: outfile = options.outfile io_fits.use('astropy') logger.info("Writing output to '%s'..." % (outfile)) try: os.remove(outfile) except OSError: pass img_mosaic.save_as_file(outfile)
def main(options, args): QtGui.QApplication.setGraphicsSystem('raster') app = QtGui.QApplication(args) app.connect(app, QtCore.SIGNAL('lastWindowClosed()'), app, QtCore.SLOT('quit()')) logger = log.get_logger(name="example3", options=options) w = FitsViewer(logger) w.resize(1024, 540) w.show() app.setActiveWindow(w) if len(args) > 0: w.load_file(args[0]) app.exec_()
def __init__(self, session, parent=None): self.logger = log.get_logger(name='ginga', log_stderr=True) self.canvas = ImageViewCanvas(self.logger, render='widget') # prevent widget from grabbing focus self.canvas.set_follow_focus(False) self.canvas.enable_overlays(True) # enable interactive features bindings = self.canvas.get_bindings() bindings.enable_all(True) self.canvas.set_callback('none-move', self.motion_readout) self.canvas.set_callback('draw-event', self._apply_roi_cb) self.canvas.set_callback('draw-down', self._clear_roi_cb) self.canvas.enable_draw(False) self.canvas.enable_autozoom('off') self.canvas.set_zoom_algorithm('rate') self.canvas.set_zoomrate(1.4) bm = self.canvas.get_bindmap() bm.add_callback('mode-set', self.mode_set_cb) self.mode_w = None self.mode_actns = {} # Create settings and set defaults settings = self.canvas.get_settings() self.settings = settings settings.getSetting('cuts').add_callback('set', self.cut_levels_cb) settings.set(autozoom='off', autocuts='override', autocenter='override') # make color bar, with color maps shared from ginga canvas self.colorbar = ColorBar.ColorBar(self.logger) rgbmap = self.canvas.get_rgbmap() rgbmap.add_callback('changed', self.rgbmap_cb, self.canvas) self.colorbar.set_rgbmap(rgbmap) # make coordinates/value readout self.readout = Readout.Readout(-1, -1) self.roi_tag = None super(GingaWidget, self).__init__(session, parent)
def main(options, args): logger = log.get_logger("ipg", options=options) server = make_server(logger=logger, basedir=options.basedir, numthreads=options.numthreads, host=options.host, port=options.port, use_opencv=options.use_opencv) viewer = server.get_viewer('v1') logger.info("Starting server with one viewer, connect at %s" % viewer.url) try: server.start(use_thread=False) except KeyboardInterrupt: logger.info("Interrupted!") server.stop() logger.info("Server terminating ...")
def main(options, args): #QtGui.QApplication.setGraphicsSystem('raster') app = QtGui.QApplication(args) logger = log.get_logger("example2", options=options) w = FitsViewer(logger) w.resize(524, 540) w.show() app.setActiveWindow(w) w.raise_() w.activateWindow() if len(args) > 0: w.load_file(args[0]) app.exec_()
def get_viewer(): # Set to True to get diagnostic logging output use_logger = False logger = log.get_logger(null=not use_logger, log_stderr=True) # create a regular matplotlib figure fig = plt.figure() # create a ginga object, initialize some defaults and # tell it about the figure viewer = CustomMplViewer(logger) viewer.enable_autocuts('on') viewer.set_autocut_params('zscale') viewer.set_figure(fig) # enable all interactive ginga features viewer.get_bindings().enable_all(True) return viewer
def main(options, args): logname = 'promsdb' logger = log.get_logger(logname, options=options) try: s = ProMSdb(logger, options.dblog) except ProMSdbError as e: result = str(e) success = False logger.info('result %s success %s' % (result, success)) exit(1) if options.id: res = s.user_in_proms(options.id) logger.info('user_in_proms result is %s' % res) if options.id and options.passwd: res = s.user_auth_in_proms(options.id, options.passwd) logger.info('user_auth_in_proms result is %s' % res)
def __init__(self, chartDev): self.chartDev = chartDev use_logger = False logger = log.get_logger(null=not use_logger, log_stderr=True) self.logger = logger # create a ginga object and tell it about the figure self.chartDev.fig.clf() fi = ImageViewCanvas(logger) fi.enable_autocuts('on') fi.set_autocut_params('zscale') fi.set_figure(self.chartDev.fig) fi.ui_setActive(True) self.fitsimage = fi setup_Qt(chartDev, fi) # enable all interactive features fi.get_bindings().enable_all(True) self.fitsimage = fi
def main(params): ginga_logger = log.get_logger("ginga", options=params) ginga_logger.addHandler( logging.FileHandler(filename=tempfile.NamedTemporaryFile( prefix='ginga', delete=False).name)) if params.use_opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as ex: ginga_logger.warning("Error using OpenCL: {}".format(ex)) if params.use_opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as ex: ginga_logger.warning("Error using OpenCL: {}".format(ex)) app = Widgets.Application(logger=ginga_logger, host=params.host, port=params.port) # create top level window window = app.make_window("Validate", wid='Validate') daomop_logger = logging.getLogger('daomop') if hasattr(params, 'loglevel'): daomop_logger.setLevel(params.loglevel) # our own viewer object, customized with methods (see above) ValidateGui(daomop_logger, window) try: app.start() except KeyboardInterrupt: ginga_logger.info("Terminating viewer...") window.close()
def main(options, args): QtGui.QApplication.setGraphicsSystem('raster') app = QtGui.QApplication(args) app.connect(app, QtCore.SIGNAL('lastWindowClosed()'), app, QtCore.SLOT('quit()')) logger = log.get_logger(name="example2", options=options) w = FitsViewer(logger) w.resize(524, 540) w.show() app.setActiveWindow(w) w.raise_() w.activateWindow() if len(args) > 0: w.load_file(args[0]) app.exec_()
def main(options, args): # Create top level logger. logger = log.get_logger(name='qcheck', options=options) if options.input_filename: # This section is for reading an Excel file that has the usual # sheets in it (targets, envcfg, etc.) # Append any directory path supplied in options.input_filename # onto the end of the options.input_dir value. input_dir = os.path.join(options.input_dir, os.path.dirname(options.input_filename)) # Parse the input filename so we can get the proposal name. input_filename = os.path.basename(options.input_filename) propname, ext = input_filename.split('.') if ext in filetypes.QueueFile.excel_ext: propdict = {} key = propname.upper() propdict[key] = entity.Program(key, hours=0, category='') progFile = filetypes.ProgramFile(input_dir, logger, propname, propdict) else: logger.error( "File extension '%s' is not a valid file type. Must be one of %s." % (ext, filetypes.QueueFile.excel_ext)) sys.exit(1) else: # This section is for reading a directory that contains CSV # files, i.e., targets.csv, inscfg.csv, etc. dirname = os.path.dirname(options.input_dir) propname = os.path.basename(options.input_dir) propdict = {} key = propname.upper() propdict[key] = entity.Program(key, hours=0, category='') progFile = filetypes.ProgramFile(dirname, logger, propname, propdict, file_ext='csv') logger.info('Warning count is %d' % progFile.warn_count) logger.info('Error count is %d' % progFile.error_count)
def main(options, args): app = QtGui.QApplication(sys.argv) # ginga needs a logger. # If you don't want to log anything you can create a null logger by # using null=True in this call instead of log_stderr=True logger = log.get_logger("fvlog", log_stderr=True) w1 = FitsViewer(logger) w1.resize(800, 133) w1.show() app.setActiveWindow(w1) w1.raise_() w1.activateWindow() if len(args) > 0: w1.load_file(args[0]) app.exec_()
def pre_init(self, fitsfile=os.path.join(script_dir, "test.fits")): #App design self.format_string = formats self.interface_file = os.path.join(script_dir, "WebbFITSViewer_interface.yaml") #Tunable settings self.pan_scale = 0.05 self.initial_zoom = 1.0 self.zoom_speed = 0.02 #initialize the Ginga backend self.logger = log.get_logger("ginga", level=20, log_file="/tmp/ginga.log") self.autocuts = AutoCuts.Histogram(self.logger) self.selected_data = None self.box_corners = [] self.pre_fitsfile = fitsfile
def main(options, args): app = QtGui.QApplication(sys.argv) # ginga needs a logger. # If you don't want to log anything you can create a null logger by # using null=True in this call instead of log_stderr=True logger = log.get_logger("example1", log_stderr=True, level=40) w = FitsViewer(logger) w.resize(524, 540) w.show() app.setActiveWindow(w) w.raise_() w.activateWindow() if len(args) > 0: w.load_file(args[0]) app.exec_()
def __init__(self): """Default constructor.""" #logger = log.get_logger(log_stderr=True, level=20) logger = log.get_logger(null=True) # Initialize base class GingaCanvas.__init__(self, logger=logger) # Keep track of all patches self.patches = {} #self.zorder=10 self.get_bindings().enable_all(True) self.enable_draw(True) self.enable_edit(True) self.set_drawtype('line', color='green', cap='ball', linewidth=2) #self.add_callback('draw-event', self.draw_cb) #self.add_callback('edit-event', self.edit_cb) self.add_callback('drag-drop', self.drop_file)
def make_server(logger=None, basedir='.', numthreads=5, host='localhost', port=9909, viewer_class=None, use_opencv=False): if logger is None: logger = log.get_logger("ipg", null=True) ev_quit = threading.Event() if use_opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("Error using opencv: %s" % str(e)) thread_pool = Task.ThreadPool(numthreads, logger, ev_quit=ev_quit) base_url = "http://%s:%d/app" % (host, port) app = Widgets.Application(logger=logger, base_url=base_url, host=host, port=port) factory = ViewerFactory(logger, app, thread_pool) server = WebServer(app, thread_pool, factory, host=host, port=port, viewer_class=viewer_class) return server
def main(self, options, args): """ Main routine for running the reference viewer. `options` is a OptionParser object that has been populated with values from parsing the command line. It should at least include the options from add_default_options() `args` is a list of arguments to the viewer after parsing out options. It should contain a list of files or URLs to load. """ # Create a logger logger = log.get_logger(name='ginga', options=options) # Get settings (preferences) basedir = paths.ginga_home if not os.path.exists(basedir): try: os.mkdir(basedir) except OSError as e: logger.warning("Couldn't create ginga settings area (%s): %s" % (basedir, str(e))) logger.warning("Preferences will not be able to be saved") # Set up preferences prefs = Settings.Preferences(basefolder=basedir, logger=logger) settings = prefs.create_category('general') settings.set_defaults(useMatplotlibColormaps=False, widgetSet='choose', WCSpkg='choose', FITSpkg='choose', recursion_limit=2000, icc_working_profile=None, font_scaling_factor=None, save_layout=True, channel_prefix="Image") settings.load(onError='silent') # default of 1000 is a little too small sys.setrecursionlimit(settings.get('recursion_limit')) # So we can find our plugins sys.path.insert(0, basedir) package_home = os.path.split(sys.modules['ginga.version'].__file__)[0] child_dir = os.path.join(package_home, 'rv', 'plugins') sys.path.insert(0, child_dir) plugin_dir = os.path.join(basedir, 'plugins') sys.path.insert(0, plugin_dir) gc = os.path.join(basedir, "ginga_config.py") have_ginga_config = os.path.exists(gc) # User configuration, earliest possible intervention if have_ginga_config: try: import ginga_config if hasattr(ginga_config, 'init_config'): ginga_config.init_config(self) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error processing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Choose a toolkit if options.toolkit: toolkit = options.toolkit else: toolkit = settings.get('widgetSet', 'choose') if toolkit == 'choose': try: ginga_toolkit.choose() except ImportError as e: print("UI toolkit choose error: %s" % str(e)) sys.exit(1) else: ginga_toolkit.use(toolkit) tkname = ginga_toolkit.get_family() logger.info("Chosen toolkit (%s) family is '%s'" % (ginga_toolkit.toolkit, tkname)) # these imports have to be here, otherwise they force the choice # of toolkit too early from ginga.rv.Control import GingaShell, GuiLogHandler if settings.get('useMatplotlibColormaps', False): # Add matplotlib color maps if matplotlib is installed try: from ginga import cmap cmap.add_matplotlib_cmaps(fail_on_import_error=False) except Exception as e: logger.warning("failed to load matplotlib colormaps: %s" % (str(e))) # Set a working RGB ICC profile if user has one working_profile = settings.get('icc_working_profile', None) rgb_cms.working_profile = working_profile # User wants to customize the WCS package? if options.wcspkg: wcspkg = options.wcspkg else: wcspkg = settings.get('WCSpkg', 'choose') try: from ginga.util import wcsmod if wcspkg != 'choose': assert wcsmod.use(wcspkg) is True except Exception as e: logger.warning("failed to set WCS package preference: %s" % (str(e))) # User wants to customize the FITS package? if options.fitspkg: fitspkg = options.fitspkg else: fitspkg = settings.get('FITSpkg', 'choose') try: from ginga.util import io_fits, loader if fitspkg != 'choose': assert io_fits.use(fitspkg) is True # opener name is not necessarily the same opener = loader.get_opener(io_fits.fitsLoaderClass.name) # set this opener as the priority one opener.priority = -99 except Exception as e: logger.warning("failed to set FITS package preference: %s" % (str(e))) # Check whether user wants to use OpenCv use_opencv = settings.get('use_opencv', False) if use_opencv or options.opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("failed to set OpenCv preference: %s" % (str(e))) # Check whether user wants to use OpenCL use_opencl = settings.get('use_opencl', False) if use_opencl or options.opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("failed to set OpenCL preference: %s" % (str(e))) # Create the dynamic module manager mm = ModuleManager.ModuleManager(logger) # Create and start thread pool ev_quit = threading.Event() thread_pool = Task.ThreadPool(options.numthreads, logger, ev_quit=ev_quit) thread_pool.startall() # Create the Ginga main object ginga_shell = GingaShell(logger, thread_pool, mm, prefs, ev_quit=ev_quit) # user wants to set font scaling. # NOTE: this happens *after* creation of shell object, since # Application object constructor will also set this font_scaling = settings.get('font_scaling_factor', None) if font_scaling is not None: logger.debug( "overriding font_scaling_factor to {}".format(font_scaling)) from ginga.fonts import font_asst font_asst.default_scaling_factor = font_scaling layout_file = None if not options.norestore and settings.get('save_layout', False): layout_file = os.path.join(basedir, 'layout') ginga_shell.set_layout(self.layout, layout_file=layout_file) # User configuration (custom star catalogs, etc.) if have_ginga_config: try: if hasattr(ginga_config, 'pre_gui_config'): ginga_config.pre_gui_config(ginga_shell) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error importing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Build desired layout ginga_shell.build_toplevel() # Did user specify a particular geometry? if options.geometry: ginga_shell.set_geometry(options.geometry) # make the list of disabled plugins if options.disable_plugins is not None: disabled_plugins = options.disable_plugins.lower().split(',') else: disabled_plugins = settings.get('disable_plugins', []) if not isinstance(disabled_plugins, list): disabled_plugins = disabled_plugins.lower().split(',') # Add GUI log handler (for "Log" global plugin) guiHdlr = GuiLogHandler(ginga_shell) guiHdlr.setLevel(options.loglevel) fmt = logging.Formatter(log.LOG_FORMAT) guiHdlr.setFormatter(fmt) logger.addHandler(guiHdlr) # Load any custom modules if options.modules is not None: modules = options.modules.split(',') else: modules = settings.get('global_plugins', []) if not isinstance(modules, list): modules = modules.split(',') for long_plugin_name in modules: if '.' in long_plugin_name: tmpstr = long_plugin_name.split('.') plugin_name = tmpstr[-1] pfx = '.'.join(tmpstr[:-1]) else: plugin_name = long_plugin_name pfx = None menu_name = "%s [G]" % (plugin_name) spec = Bunch(name=plugin_name, module=plugin_name, ptype='global', tab=plugin_name, menu=menu_name, category="Custom", workspace='right', pfx=pfx) self.add_plugin_spec(spec) # Load any custom local plugins if options.plugins is not None: plugins = options.plugins.split(',') else: plugins = settings.get('local_plugins', []) if not isinstance(plugins, list): plugins = plugins.split(',') for long_plugin_name in plugins: if '.' in long_plugin_name: tmpstr = long_plugin_name.split('.') plugin_name = tmpstr[-1] pfx = '.'.join(tmpstr[:-1]) else: plugin_name = long_plugin_name pfx = None spec = Bunch(module=plugin_name, workspace='dialogs', ptype='local', category="Custom", hidden=False, pfx=pfx) self.add_plugin_spec(spec) # Add non-disabled plugins enabled_plugins = [ spec for spec in self.plugins if spec.module.lower() not in disabled_plugins ] ginga_shell.set_plugins(enabled_plugins) # start any plugins that have start=True ginga_shell.boot_plugins() ginga_shell.update_pending() # TEMP? tab_names = [ name.lower() for name in ginga_shell.ds.get_tabnames(group=None) ] if 'info' in tab_names: ginga_shell.ds.raise_tab('Info') if 'synopsis' in tab_names: ginga_shell.ds.raise_tab('Synopsis') if 'thumbs' in tab_names: ginga_shell.ds.raise_tab('Thumbs') # Add custom channels if options.channels is not None: channels = options.channels.split(',') else: channels = settings.get('channels', self.channels) if not isinstance(channels, list): channels = channels.split(',') if len(channels) == 0: # should provide at least one default channel? channels = [settings.get('channel_prefix', "Image")] # populate the initial channel lineup for item in channels: if isinstance(item, str): chname, wsname = item, None else: chname, wsname = item ginga_shell.add_channel(chname, workspace=wsname) ginga_shell.change_channel(chname) # User configuration (custom star catalogs, etc.) if have_ginga_config: try: if hasattr(ginga_config, 'post_gui_config'): ginga_config.post_gui_config(ginga_shell) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error processing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Redirect warnings to logger for hdlr in logger.handlers: logging.getLogger('py.warnings').addHandler(hdlr) # Display banner the first time run, unless suppressed show_banner = True try: show_banner = settings.get('showBanner') except KeyError: # disable for subsequent runs settings.set(showBanner=False) if not os.path.exists(settings.preffile): settings.save() if (not options.nosplash) and (len(args) == 0) and show_banner: ginga_shell.banner(raiseTab=True) # Handle inputs like "*.fits[ext]" that sys cmd cannot auto expand. expanded_args = [] for imgfile in args: if '*' in imgfile: if '[' in imgfile and imgfile.endswith(']'): s = imgfile.split('[') ext = '[' + s[1] imgfile = s[0] else: ext = '' for fname in glob.iglob(imgfile): expanded_args.append(fname + ext) else: expanded_args.append(imgfile) # Assume remaining arguments are fits files and load them. if not options.separate_channels: chname = channels[0] ginga_shell.gui_do(ginga_shell.open_uris, expanded_args, chname=chname) else: i = 0 num_channels = len(channels) for imgfile in expanded_args: if i < num_channels: chname = channels[i] i = i + 1 else: channel = ginga_shell.add_channel_auto() chname = channel.name ginga_shell.gui_do(ginga_shell.open_uris, [imgfile], chname=chname) try: try: # if there is a network component, start it if hasattr(ginga_shell, 'start'): logger.info("starting network interface...") task = Task.FuncTask2(ginga_shell.start) thread_pool.addTask(task) # Main loop to handle GUI events logger.info("entering mainloop...") ginga_shell.mainloop(timeout=0.001) except KeyboardInterrupt: logger.error("Received keyboard interrupt!") finally: logger.info("Shutting down...") ev_quit.set() sys.exit(0)
if top is not None: top.delete() sys.exit() def popup_dialog(parent): dia = Widgets.Dialog(title="Dialog Title", buttons=[('ok', 0), ('cancel', 1)], parent=parent, modal=True) cntr = dia.get_content_area() cntr.add_widget(Widgets.Label("My Dialog Content")) dia.show() logger = log.get_logger('test', log_stderr=True, level=20) app = Widgets.Application(logger=logger) if hasattr(app, 'script_imports'): app.script_imports.append('jqx') app.add_callback('shutdown', quit) top = app.make_window("Ginga Wrapped Widgets Example: %s" % (wname)) top.add_callback('close', quit) vbox = Widgets.VBox() vbox.set_border_width(2) vbox.set_spacing(1) dia = None if wname == 'label':
def __init__(self, exam=None, close_on_del=True, logger=None, port=None): """initialize a general ginga viewer object. Parameters ---------- exam: imexam object This is the imexamine object which contains the examination functions close_on_del: bool If True, the window connection shuts down when the object is deleted logger: logger object Ginga viewers all need a logger, if none is provided it will create one port: int This is used as the communication port for the HTML5 viewer. The user can choose to have multiple windows open at the same time as long as they have different port designations. If no port is specified, this class will choose an open port. """ global _matplotlib_cmaps_added self._port = port self.exam = exam self._close_on_del = close_on_del # dictionary where each key is a frame number, and the values are a # dictionary of details about the image loaded in that frame self._viewer = dict() self._current_frame = 1 self._current_slice = None # ginga view object, created in subclass self.ginga_view = None # set up possible color maps self._define_cmaps() # for synchronizing on keystrokes self._rlock = threading.RLock() # this creates a thread lock self._keyvals = list() self._capturing = False # ginga objects need a logger, create a null one if we are not # handed one in the constructor self._log_level = 40 if logger is None: logger = log.get_logger(level=self._log_level, log_stderr=True) self.logger = logger # Establish settings (preferences) for ginga viewers basedir = paths.ginga_home self.prefs = Settings.Preferences(basefolder=basedir, logger=self.logger) # general preferences shared with other ginga viewers self.settings = self.prefs.createCategory('general') self.settings.load(onError='silent') self.settings.setDefaults(useMatplotlibColormaps=False, autocuts='on', autocut_method='zscale') # add matplotlib colormaps to ginga's own set if user has this # preference set if self.settings.get('useMatplotlibColormaps', False) and \ (not _matplotlib_cmaps_added): # Add matplotlib color maps if matplotlib is installed try: cmap.add_matplotlib_cmaps() _matplotlib_cmaps_added = True except Exception as e: print(f"Failed to load matplotlib colormaps: {repr(e)}") # bindings preferences shared with other ginga viewers bind_prefs = self.prefs.createCategory('bindings') bind_prefs.load(onError='silent') # viewer preferences unique to imexam ginga viewers viewer_prefs = self.prefs.createCategory('imexam') viewer_prefs.load(onError='silent') # create the viewer specific to this backend self._create_viewer(bind_prefs, viewer_prefs) # TODO: at some point, it might be better to simply add a custom # mode called "imexam"--that is a more robust way to do things # but we'd have to register the imexam key bindings in a different way # bm = self.ginga_view.get_bindmap() # bm.add_mode('i', 'imexam', mode_type='locked', # msg="Entering imexam mode...") # modifiers_set = bindmap.get_modifiers() # bm.map_event('imexam', modifiers_set, trigger, evname) # enable all interactive ginga features bindings = self.ginga_view.get_bindings() bindings.enable_all(True) # Add a callback to take us into imexam mode top_canvas = self.ginga_view.get_canvas() top_canvas.add_callback('key-press', self._key_press_normal) # Add a callback to our private canvas to take us out of imexam mode self.canvas.enable_draw(False) self.canvas.add_callback('key-press', self._key_press_imexam) self.canvas.set_surface(self.ginga_view) self.canvas.ui_setActive(True)
parser.add_argument( '--sepath', dest='sepath', default=None, help= 'path to source extractor config files (e.g. ~/github/HalphaImaging/astromatic/ - this is default if no path is given.)' ) parser.add_argument( '--config', dest='config', default=None, help='source extractor config file. default is default.sex.HDI.mask') args = parser.parse_args() logger = log.get_logger("masklog", log_stderr=True, level=40) app = QtWidgets.QApplication(sys.argv) #MainWindow = QtWidgets.QMainWindow() MainWindow = QtWidgets.QWidget() if args.image is not None: ui = maskwindow(MainWindow, logger, image=args.image, haimage=args.haimage, sepath=args.sepath, config=args.config) else: ui = maskwindow(MainWindow, logger) #ui.setupUi(MainWindow) #ui.test()
def main(self, options, args): # Create top level logger. svcname = 'qplan' logger = log.get_logger(name=svcname, options=options) logger.info("starting qplan %s" % (version.version)) ev_quit = threading.Event() thread_pool = Task.ThreadPool(logger=logger, ev_quit=ev_quit, numthreads=options.numthreads) if options.toolkit is not None: ginga_toolkit.use(options.toolkit) else: ginga_toolkit.choose() tkname = ginga_toolkit.get_family() logger.info("Chosen toolkit (%s) family is '%s'" % (ginga_toolkit.toolkit, tkname)) from qplan.View import Viewer # must import AFTER Viewer from ginga.rv.Control import GuiLogHandler class QueuePlanner(Controller, Viewer): def __init__(self, logger, thread_pool, module_manager, preferences, ev_quit, model): Viewer.__init__(self, logger, ev_quit) Controller.__init__(self, logger, thread_pool, module_manager, preferences, ev_quit, model) # Get settings folder if 'CONFHOME' in os.environ: basedir = os.path.join(os.environ['CONFHOME'], svcname) else: basedir = os.path.join(os.environ['HOME'], '.' + svcname) if not os.path.exists(basedir): os.mkdir(basedir) prefs = Settings.Preferences(basefolder=basedir, logger=logger) settings = prefs.create_category('general') settings.load(onError='silent') settings.set_defaults(output_dir=options.output_dir, save_layout=False) mm = ModuleManager.ModuleManager(logger) ## # Add any custom modules ## if options.modules: ## modules = options.modules.split(',') ## for mdlname in modules: ## #self.mm.loadModule(name, pfx=pluginconfpfx) ## self.mm.loadModule(name) observer = site.get_site(options.sitename) scheduler = Scheduler(logger, observer) model = QueueModel(logger, scheduler) if options.completed is not None: import json logger.info("reading executed OBs from '{}' ...".format( options.completed)) # user specified a set of completed OB keys with open(options.completed, 'r') as in_f: buf = in_f.read() d = json.loads(buf) model.completed_obs = {(propid, obcode): d[propid][obcode] for propid in d for obcode in d[propid]} # Start up the control/display engine qplanner = QueuePlanner(logger, thread_pool, mm, prefs, ev_quit, model) qplanner.set_input_dir(options.input_dir) qplanner.set_input_fmt(options.input_fmt) layout_file = None if not options.norestore and settings.get('save_layout', False): layout_file = os.path.join(basedir, 'layout') # Build desired layout qplanner.build_toplevel(default_layout, layout_file=layout_file) for w in qplanner.ds.toplevels: w.show() # load plugins for spec in plugins: qplanner.load_plugin(spec.name, spec) # start any plugins that have start=True qplanner.boot_plugins() qplanner.ds.raise_tab('Control Panel') guiHdlr = GuiLogHandler(qplanner) #guiHdlr.setLevel(options.loglevel) guiHdlr.setLevel(logging.INFO) fmt = logging.Formatter(log.LOG_FORMAT) guiHdlr.setFormatter(fmt) logger.addHandler(guiHdlr) qplanner.update_pending() # Did user specify geometry if options.geometry: qplanner.set_geometry(options.geometry) # Raise window w = qplanner.w.root w.show() server_started = False # Create threadpool and start it try: # Startup monitor threadpool thread_pool.startall(wait=True) try: # if there is a network component, start it if hasattr(qplanner, 'start'): task = Task.FuncTask2(qplanner.start) thread_pool.addTask(task) # Main loop to handle GUI events qplanner.mainloop(timeout=0.001) except KeyboardInterrupt: logger.error("Received keyboard interrupt!") finally: logger.info("Shutting down...") thread_pool.stopall(wait=True) sys.exit(0)
def setup_class(self): self.logger = log.get_logger("TestAstroImage", null=True) self.image = AstroImage.AstroImage(logger=self.logger)
def main(self, options, args): """ Main routine for running the reference viewer. `options` is a OptionParser object that has been populated with values from parsing the command line. It should at least include the options from add_default_options() `args` is a list of arguments to the viewer after parsing out options. It should contain a list of files or URLs to load. """ # Create a logger logger = log.get_logger(name='ginga', options=options) # Get settings (preferences) basedir = paths.ginga_home if not os.path.exists(basedir): try: os.mkdir(basedir) except OSError as e: logger.warn("Couldn't create ginga settings area (%s): %s" % (basedir, str(e))) logger.warn("Preferences will not be able to be saved") # Set up preferences prefs = Settings.Preferences(basefolder=basedir, logger=logger) settings = prefs.createCategory('general') settings.load(onError='silent') settings.setDefaults(useMatplotlibColormaps=False, widgetSet='choose', WCSpkg='choose', FITSpkg='choose', recursion_limit=2000) # default of 1000 is a little too small sys.setrecursionlimit(settings.get('recursion_limit')) # So we can find our plugins sys.path.insert(0, basedir) moduleHome = os.path.split(sys.modules['ginga.version'].__file__)[0] childDir = os.path.join(moduleHome, 'misc', 'plugins') sys.path.insert(0, childDir) pluginDir = os.path.join(basedir, 'plugins') sys.path.insert(0, pluginDir) # Choose a toolkit if options.toolkit: toolkit = options.toolkit else: toolkit = settings.get('widgetSet', 'choose') if toolkit == 'choose': try: from ginga.qtw import QtHelp except ImportError: try: from ginga.gtkw import GtkHelp except ImportError: print("You need python-gtk or python-qt to run Ginga!") sys.exit(1) else: ginga_toolkit.use(toolkit) tkname = ginga_toolkit.get_family() logger.info("Chosen toolkit (%s) family is '%s'" % (ginga_toolkit.toolkit, tkname)) # these imports have to be here, otherwise they force the choice # of toolkit too early from ginga.gw.GingaGw import GingaView from ginga.Control import GingaControl, GuiLogHandler # Define class dynamically based on toolkit choice class GingaShell(GingaControl, GingaView): def __init__(self, logger, thread_pool, module_manager, prefs, ev_quit=None): GingaView.__init__(self, logger, ev_quit, thread_pool) GingaControl.__init__(self, logger, thread_pool, module_manager, prefs, ev_quit=ev_quit) if settings.get('useMatplotlibColormaps', False): # Add matplotlib color maps if matplotlib is installed try: from ginga import cmap cmap.add_matplotlib_cmaps() except Exception as e: logger.warn("failed to load matplotlib colormaps: %s" % (str(e))) # User wants to customize the WCS package? if options.wcspkg: wcspkg = options.wcspkg else: wcspkg = settings.get('WCSpkg', 'choose') try: from ginga.util import wcsmod assert wcsmod.use(wcspkg) == True except Exception as e: logger.warn("failed to set WCS package preference: %s" % (str(e))) # User wants to customize the FITS package? if options.fitspkg: fitspkg = options.fitspkg else: fitspkg = settings.get('FITSpkg', 'choose') try: from ginga.util import io_fits assert io_fits.use(fitspkg) == True except Exception as e: logger.warn("failed to set FITS package preference: %s" % (str(e))) # Check whether user wants to use OpenCv use_opencv = settings.get('use_opencv', False) if use_opencv or options.opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warn("failed to set OpenCv preference: %s" % (str(e))) # Create the dynamic module manager mm = ModuleManager.ModuleManager(logger) # Create and start thread pool ev_quit = threading.Event() thread_pool = Task.ThreadPool(options.numthreads, logger, ev_quit=ev_quit) thread_pool.startall() # Create the Ginga main object ginga_shell = GingaShell(logger, thread_pool, mm, prefs, ev_quit=ev_quit) ginga_shell.set_layout(self.layout) gc = os.path.join(basedir, "ginga_config.py") have_ginga_config = os.path.exists(gc) # User configuration (custom star catalogs, etc.) if have_ginga_config: try: import ginga_config ginga_config.pre_gui_config(ginga_shell) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error importing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Build desired layout ginga_shell.build_toplevel() # Did user specify a particular geometry? if options.geometry: ginga_shell.set_geometry(options.geometry) # make the list of disabled plugins disabled_plugins = [] if not (options.disable_plugins is None): disabled_plugins = options.disable_plugins.lower().split(',') # Add desired global plugins for spec in self.global_plugins: if not spec.module.lower() in disabled_plugins: ginga_shell.add_global_plugin(spec) # Add GUI log handler (for "Log" global plugin) guiHdlr = GuiLogHandler(ginga_shell) guiHdlr.setLevel(options.loglevel) fmt = logging.Formatter(log.LOG_FORMAT) guiHdlr.setFormatter(fmt) logger.addHandler(guiHdlr) # Load any custom modules if options.modules: modules = options.modules.split(',') for longPluginName in modules: if '.' in longPluginName: tmpstr = longPluginName.split('.') pluginName = tmpstr[-1] pfx = '.'.join(tmpstr[:-1]) else: pluginName = longPluginName pfx = None spec = Bunch(name=pluginName, module=pluginName, tab=pluginName, ws='right', pfx=pfx) ginga_shell.add_global_plugin(spec) # Load modules for "local" (per-channel) plug ins for spec in self.local_plugins: if not spec.module.lower() in disabled_plugins: ginga_shell.add_local_plugin(spec) # Load any custom plugins if options.plugins: plugins = options.plugins.split(',') for longPluginName in plugins: if '.' in longPluginName: tmpstr = longPluginName.split('.') pluginName = tmpstr[-1] pfx = '.'.join(tmpstr[:-1]) else: pluginName = longPluginName pfx = None spec = Bunch(module=pluginName, ws='dialogs', hidden=False, pfx=pfx) ginga_shell.add_local_plugin(spec) ginga_shell.update_pending() # TEMP? tab_names = list( map(lambda name: name.lower(), ginga_shell.ds.get_tabnames(group=None))) if 'info' in tab_names: ginga_shell.ds.raise_tab('Info') if 'thumbs' in tab_names: ginga_shell.ds.raise_tab('Thumbs') # Add custom channels channels = options.channels.split(',') for chname in channels: ginga_shell.add_channel(chname) ginga_shell.change_channel(channels[0]) # User configuration (custom star catalogs, etc.) if have_ginga_config: try: ginga_config.post_gui_config(ginga_shell) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error processing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Redirect warnings to logger for hdlr in logger.handlers: logging.getLogger('py.warnings').addHandler(hdlr) # Display banner the first time run, unless suppressed showBanner = True try: showBanner = settings.get('showBanner') except KeyError: # disable for subsequent runs settings.set(showBanner=False) settings.save() if (not options.nosplash) and (len(args) == 0) and showBanner: ginga_shell.banner(raiseTab=True) # Assume remaining arguments are fits files and load them. for imgfile in args: ginga_shell.nongui_do(ginga_shell.load_file, imgfile) try: try: # if there is a network component, start it if hasattr(ginga_shell, 'start'): task = Task.FuncTask2(ginga_shell.start) thread_pool.addTask(task) # Main loop to handle GUI events logger.info("Entering mainloop...") ginga_shell.mainloop(timeout=0.001) except KeyboardInterrupt: logger.error("Received keyboard interrupt!") finally: logger.info("Shutting down...") ev_quit.set() sys.exit(0)
def main(options, args): # default of 1000 is a little too small sys.setrecursionlimit(2000) # Create a logger logger = log.get_logger(name='ginga', options=options) # Get settings (preferences) basedir = paths.ginga_home if not os.path.exists(basedir): try: os.mkdir(basedir) except OSError as e: logger.warn("Couldn't create ginga settings area (%s): %s" % (basedir, str(e))) logger.warn("Preferences will not be able to be saved") # Set up preferences prefs = Settings.Preferences(basefolder=basedir, logger=logger) settings = prefs.createCategory('general') settings.load(onError='silent') settings.setDefaults(useMatplotlibColormaps=False, widgetSet='choose', WCSpkg='choose', FITSpkg='choose') # So we can find our plugins sys.path.insert(0, basedir) moduleHome = os.path.split(sys.modules['ginga.version'].__file__)[0] childDir = os.path.join(moduleHome, 'misc', 'plugins') sys.path.insert(0, childDir) pluginDir = os.path.join(basedir, 'plugins') sys.path.insert(0, pluginDir) # Choose a toolkit if options.toolkit: toolkit = options.toolkit else: toolkit = settings.get('widgetSet', 'choose') ginga_toolkit.use(toolkit) tkname = ginga_toolkit.get_family() if tkname == 'gtk': from ginga.gtkw.GingaGtk import GingaView elif tkname == 'qt': from ginga.qtw.GingaQt import GingaView else: try: from ginga.qtw.GingaQt import GingaView except ImportError: try: from ginga.gtkw.GingaGtk import GingaView except ImportError: print("You need python-gtk or python-qt4 to run Ginga!") sys.exit(1) # Define class dynamically based on toolkit choice class Ginga(GingaControl, GingaView): def __init__(self, logger, threadPool, module_manager, prefs, ev_quit=None): GingaView.__init__(self, logger, ev_quit) GingaControl.__init__(self, logger, threadPool, module_manager, prefs, ev_quit=ev_quit) if settings.get('useMatplotlibColormaps', False): # Add matplotlib color maps if matplotlib is installed try: from ginga import cmap cmap.add_matplotlib_cmaps() except Exception as e: logger.warn("failed to load matplotlib colormaps: %s" % (str(e))) # User wants to customize the WCS package? if options.wcs: wcspkg = options.wcs else: wcspkg = settings.get('WCSpkg', 'choose') try: from ginga.util import wcsmod assert wcsmod.use(wcspkg) == True except Exception as e: logger.warn("failed to set WCS package preference: %s" % (str(e))) # User wants to customize the FITS package? if options.fits: fitspkg = options.fits else: fitspkg = settings.get('FITSpkg', 'choose') try: from ginga.util import io_fits assert io_fits.use(fitspkg) == True except Exception as e: logger.warn("failed to set FITS package preference: %s" % (str(e))) # Create the dynamic module manager mm = ModuleManager.ModuleManager(logger) # Create and start thread pool ev_quit = threading.Event() threadPool = Task.ThreadPool(options.numthreads, logger, ev_quit=ev_quit) threadPool.startall() # Create the Ginga main object ginga = Ginga(logger, threadPool, mm, prefs, ev_quit=ev_quit) ginga.set_layout(default_layout) # User configuration (custom star catalogs, etc.) try: import ginga_config ginga_config.pre_gui_config(ginga) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error importing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Build desired layout ginga.build_toplevel() # Did user specify a particular geometry? if options.geometry: ginga.setGeometry(options.geometry) # Add desired global plugins for spec in global_plugins: ginga.add_global_plugin(spec) # Add GUI log handler (for "Log" global plugin) guiHdlr = GuiLogHandler(ginga) guiHdlr.setLevel(options.loglevel) fmt = logging.Formatter(log.LOG_FORMAT) guiHdlr.setFormatter(fmt) logger.addHandler(guiHdlr) # Load any custom modules if options.modules: modules = options.modules.split(',') for pluginName in modules: spec = Bunch(name=pluginName, module=pluginName, tab=pluginName, ws='right') ginga.add_global_plugin(spec) # Load modules for "local" (per-channel) plug ins for spec in local_plugins: ginga.add_local_plugin(spec) # Load any custom plugins if options.plugins: plugins = options.plugins.split(',') for pluginName in plugins: spec = Bunch(module=pluginName, ws='dialogs', hidden=False) ginga.add_local_plugin(spec) ginga.update_pending() # TEMP? ginga.ds.raise_tab('Info') ginga.ds.raise_tab('Thumbs') # Add custom channels channels = options.channels.split(',') for chname in channels: datasrc = Datasrc.Datasrc(length=options.bufsize) ginga.add_channel(chname, datasrc) ginga.change_channel(channels[0]) # User configuration (custom star catalogs, etc.) try: ginga_config.post_gui_config(ginga) except Exception as e: try: (type, value, tb) = sys.exc_info() tb_str = "\n".join(traceback.format_tb(tb)) except Exception: tb_str = "Traceback information unavailable." logger.error("Error processing Ginga config file: %s" % (str(e))) logger.error("Traceback:\n%s" % (tb_str)) # Display banner the first time run, unless suppressed showBanner = True try: showBanner = settings.get('showBanner') except KeyError: # disable for subsequent runs settings.set(showBanner=False) settings.save() if (not options.nosplash) and (len(args) == 0) and showBanner: ginga.banner() # Assume remaining arguments are fits files and load them. for imgfile in args: ginga.nongui_do(ginga.load_file, imgfile) try: try: # Main loop to handle GUI events logger.info("Entering mainloop...") ginga.mainloop(timeout=0.001) except KeyboardInterrupt: logger.error("Received keyboard interrupt!") finally: logger.info("Shutting down...") ev_quit.set() sys.exit(0)
objs.append(viewer.dc.Path(pts, **kwargs)) return viewer.dc.CompoundObject(*objs) def plot_sphere(viewer, r): # sphere u = np.linspace(0, np.pi, 30) v = np.linspace(0, 2 * np.pi, 30) x = np.outer(np.sin (u), np.sin (v)) * r y = np.outer(np.sin (u), np.cos (v)) * r z = np.outer(np.cos (u), np.ones_like (v)) * r wf = get_wireframe(viewer, x, y, z, color='cyan', alpha=0.3) viewer.canvas.add(wf) logger = log.get_logger('example', level=20, log_stderr=True) app = Widgets.Application(logger) v = Viewer(app) v.top.resize(512, 512) v.top.show() # put viewer in camera mode bm = v.vw.get_bindmap() bm.set_mode('camera', mode_type='locked') # toggle 3D view bd = v.vw.get_bindings() bd.kp_camera_toggle3d(v.vw, None, 0, 0)
def btn_up(self, canvas, button, data_x, data_y): ra, dec = self.get_wcs(data_x, data_y) print("button %s released at data %d,%d ra=%s dec=%s" % (button, data_x, data_y, ra, dec)) return False def draw_event(self, canvas, tag): obj = canvas.get_object_by_tag(tag) data_x, data_y = obj.x, obj.y ra, dec = self.get_wcs(data_x, data_y) print("A %s was drawn at data %d,%d ra=%s dec=%s" % (obj.kind, data_x, data_y, ra, dec)) return True # create a regular matplotlib figure fig = plt.figure() # Here is our object logger = log.get_logger(null=not use_logger, log_stderr=True) foo = MyGingaFigure(logger, fig) # load an image, if one was provided if len(sys.argv) > 1: foo.load(sys.argv[1]) # Press 'x' to turn on capture of events. Press it again to resume normal # processing of events. # Press 'c' to clear the canvas of drawn points. plt.show()
self.residual_data = fits.getdata(self.output_image,3) self.model_frame.load_image(self.model_data) self.residual_frame.load_image(self.residual_data) pass ### THIS SHOULD BE MOVED TO PARENT PROGRAM ### BECAUSE HOW U DISPLAY RESULTS WILL VARY WITH USAGE def closeEvent(self, event): # send signal that window is closed event.accept() if __name__ == "__main__": #catalog = '/Users/rfinn/research/NSA/nsa_v0_1_2.fits' #gcat = galaxy_catalog(catalog) #from halphamain import cutout_image #from halphamain import cutout_image logger = log.get_logger("galfitlog", log_stderr=True, level=40) app = QtWidgets.QApplication(sys.argv) #MainWindow = QtWidgets.QMainWindow() MainWindow = QtWidgets.QWidget() ui = galfitwindow(MainWindow, logger, image='MKW8-18216-R.fits', mask_image = 'MKW8-18216-R-mask.fits', psf='MKW8_R.coadd-psf.fits',psf_oversampling=2.) #ui.setupUi(MainWindow) #ui.test() MainWindow.show() sys.exit(app.exec_())
def main(options, args): #logger = log.get_logger("ginga", options=options) logger = log.get_logger("ginga", level=20, log_file="/tmp/ginga.log") #TOOLS = "pan,wheel_zoom,box_select,tap" TOOLS = "box_select" # create a new plot with default tools, using figure fig = figure(x_range=[0, 600], y_range=[0, 600], plot_width=600, plot_height=600, tools=TOOLS) viewer = ib.CanvasView(logger) viewer.set_figure(fig) bd = viewer.get_bindings() bd.enable_all(True) ## box_select_tool = fig.select(dict(type=BoxSelectTool)) ## box_select_tool.select_every_mousemove = True #tap_tool = fig.select_one(TapTool).renderers = [cr] # open a session to keep our local document in sync with server #session = push_session(curdoc()) #curdoc().add_periodic_callback(update, 50) def load_file(path): image = AstroImage(logger=logger) image.load_file(path) viewer.set_image(image) def load_file_cb(attr_name, old_val, new_val): #print(attr_name, old_val, new_val) load_file(new_val) def zoom_ctl_cb(attr_name, old_val, new_val): if new_val >= 0: new_val += 2 viewer.zoom_to(int(new_val)) scale = viewer.get_scale() logger.info("%f" % scale) viewer.onscreen_message("%f" % (scale), delay=0.3) # add a entry widget and configure with the call back #dstdir = options.indir dstdir = "" path_w = TextInput(value=dstdir, title="File:") path_w.on_change('value', load_file_cb) slide = Slider(start=-20, end=20, step=1, value=1) slide.on_change('value', zoom_ctl_cb) layout = column(fig, path_w, slide) curdoc().add_root(layout) if len(args) > 0: load_file(args[0])