def __init__(self): QtGui.QMainWindow.__init__(self) self.ui = Ui_RGBComposite.Ui_RGBComposite() self.ui.setupUi(self) # Helioviewer client self._hv = HelioviewerClient() self._datasources = None # Loaded images self.red = None self.green = None self.blue = None # Color channel weights self._weights = [1., 1., 1.] # Setup UI self._load_data_sources() # Load initial data self._load_defaults() # Initialize event handlers self._initEvents()
def get_helioviewer_client(): hv = HelioviewerClient() if not _is_online(hv): # fall back to mirror server print("https://www.helioviewer.org/ seems to be offline," "switching to mirror at https://helioviewer.ias.u-psud.fr/") hv = HelioviewerClient("https://helioviewer-api.ias.u-psud.fr/") return hv
def fetch_image(date, obs, ins, det, meas): hv = HelioviewerClient() filepath = hv.download_jp2(date,observatory=obs, instrument=ins, detector=det, measurement=meas) print filepath hmi = sunpy.map.Map(filepath) hmi.meta['CROTA2'] = 0 fig = plt.figure() hmi.plot() plt.colorbar() return mpld3.fig_to_html(fig, template_type='notebook')
def client(): """ Fixture to create a client and skip tests if not available """ try: client = HelioviewerClient() client.sources = client.get_data_sources() return client except urllib.error.HTTPError as e: print("There's a HTTP problem {} {}".format(e.code, e.args)) pytest.skip("HTTP error {}".format(e.code))
def client(): """ Fixture to create a client and skip tests if not available """ try: client = HelioviewerClient() client.sources = client.get_data_sources() return client except urllib.error.HTTPError as e: print("There's a HTTP problem {} {}".format(e.code, e.args)) pytest.skip("HTTP error {}".format(e.code))
def hello(): hv = HelioviewerClient() datasources = hv.get_data_sources() entries = [] for observatory, instruments in datasources.items(): for inst, detectors in instruments.items(): for det, measurements in detectors.items(): for meas, params in measurements.items(): entry = OrderedDict() entry['name'] = params['nickname'] entry['obs'] = observatory entry['val'] = observatory + "," + inst + "," + det + "," + meas entries.append(entry) print entries return render_template('index.html',evs=event_types, entries=entries)
def __init__(self): QtGui.QMainWindow.__init__(self) self.ui = Ui_RGBComposite.Ui_RGBComposite() self.ui.setupUi(self) # Helioviewer client self._hv = HelioviewerClient() self._datasources = None # Loaded images self.red = None self.green = None self.blue = None # Color channel weights self._weights = [1.0, 1.0, 1.0] # Setup UI self._load_data_sources() # Load initial data self._load_defaults() # Initialize event handlers self._initEvents()
class TestHelioviewerClient: """Tests the Helioviewer.org API Client class""" def setup_class(self): self.client = HelioviewerClient() self.sources = self.client.get_data_sources() def teardown_class(self): self.client = None def test_get_datasources(self): """Makes sure datasource query returns a valid result and source id is casted to an integer""" assert type( self.sources['SDO']['AIA']['AIA']['171']['sourceId']) is int def test_get_closest_image(self): """Tests getClosestImage API method""" # check basic query im1 = self.client.get_closest_image('1994/01/01', observatory='SOHO', instrument='EIT', detector='EIT', measurement='195') assert im1['width'] == im1['height'] == 1024 # result should be same when using source id to query source_id = self.sources['SOHO']['EIT']['EIT']['195']['sourceId'] im2 = self.client.get_closest_image('1994/01/01', sourceId=source_id) assert im1 == im2 def test_download_jp2(self): """Tests getJP2Image API method""" filepath = self.client.download_jp2('2020/01/01', observatory='SOHO', instrument='MDI', detector='MDI', measurement='continuum') try: map_ = sunpy.make_map(filepath) except sunpy.io.jp2.MissingOpenJPEGBinaryError: # We can't test JP2 decoding if binary is not available pass else: assert isinstance(map_, sunpy.Map)
class TestHelioviewerClient: """Tests the Helioviewer.org API Client class""" def setup_class(self): self.client = HelioviewerClient() self.sources = self.client.get_data_sources() def teardown_class(self): self.client = None def test_get_datasources(self): """Makes sure datasource query returns a valid result and source id is casted to an integer""" assert type(self.sources['SDO']['AIA']['AIA']['171']['sourceId']) is int def test_get_closest_image(self): """Tests getClosestImage API method""" # check basic query im1 = self.client.get_closest_image('1994/01/01', observatory='SOHO', instrument='EIT', detector='EIT', measurement='195') assert im1['width'] == im1['height'] == 1024 # result should be same when using source id to query source_id = self.sources['SOHO']['EIT']['EIT']['195']['sourceId'] im2 = self.client.get_closest_image('1994/01/01', sourceId=source_id) assert im1 == im2 def test_download_jp2(self): """Tests getJP2Image API method""" filepath = self.client.download_jp2('2020/01/01', observatory='SOHO', instrument='MDI', detector='MDI', measurement='continuum') try: map_ = sunpy.make_map(filepath) except sunpy.io.jp2.MissingOpenJPEGBinaryError: # We can't test JP2 decoding if binary is not available pass else: assert isinstance(map_, sunpy.Map)
def test_progress_png(self, client, capsys): """ Tests if progress bars are disabled when running `download_png()`. """ msg = "\rFiles Downloaded:" client = HelioviewerClient() client.download_png('2012/07/16 10:08:00', 2.4, "[SDO,AIA,AIA,171,1,100]", x0=0, y0=0, width=1024, height=1024, progress=False) _, err = capsys.readouterr() assert msg not in err client.download_png('2012/07/16 10:08:00', 2.4, "[SDO,AIA,AIA,171,1,100]", x0=0, y0=0, width=1024, height=1024) _, err = capsys.readouterr() assert msg in err
def get_images(path): #constantes for file in glob.glob('%s/*.dat' % (path)): df_solarflayers = pd.read_csv( file, sep='\t', header=None ) #, usecols=[0, 1, 2], names=['STARTT', 'MAXFlux', 'ENDT'])#, index=None) for index, event in df_solarflayers.iterrows(): for c in range(2): year, month, day, hour, minute, second = event[c][:4], event[ c][5:7], event[c][8:10], event[c][11:13], event[c][ 14:16], event[c][17:19] print('La imagen con fecha %s se esta descargando ...' % (year + '/' + month + '/' + day + ':' + hour + ':' + minute + ':' + second + '\n')) hv = HelioviewerClient() # data_sources = hv.get_data_sources() filepath = hv.download_jp2( '%s/%s/%s %s:%s:%s' % (year, month, day, hour, minute, second), observatory='SDO', instrument='HMI', measurement='magnetogram')
def test_progress_jp2(self, client, capsys): """ Tests if progress bars are disabled when running `download_jp2()`. """ client = HelioviewerClient() client.download_jp2("2012/01/01", observatory="SOHO", instrument="MDI", measurement="continuum", progress=False) out, err = capsys.readouterr() assert err == "" client.download_jp2("2012/01/01", observatory="SOHO", instrument="MDI", measurement="continuum") out, err = capsys.readouterr() assert err != ""
def gather_files(self): """ Downloads and/or concatenate into all files used for creating images and producing the final movie """ # use helioviewer if requested if self.usehv: from sunpy.net.helioviewer import HelioviewerClient import matplotlib.image as mpimg hv = HelioviewerClient() dayarray = glob.glob(self.sdir + '/raw/*jp2') forpool = np.arange(len(dayarray)) #for i in forpool: format_img(i) pool2 = Pool(processes=nproc) outs = pool2.map(get_file, forpool) pool2.close() #video wall ratio self.rv = float(self.w0) / float(self.h0) #scale up the images with increasing dpi self.sc = self.dpi / 100 self.span = ( self.end - self.start).total_seconds() #seconds to run the movie over #create a directory which will contain the raw png files #sdir = stard+eday.date().strftime('%Y%m%d') #creating a subdirectory to extra step is not need dirlist = [ self.sdir, self.sdir + '/raw', self.sdir + '/working', self.sdir + '/working/symlinks', self.sdir + '/final', self.sdir + '/goes', self.sdir + '/ace' ] for i in dirlist: self.create_dir(i) #get all days in date time span if self.goes: ggxf.look_xrays(self.start, self.end + dt(days=1), self.sdir, email=self.email) goesfil = glob.glob(self.sdir + '/goes/*txt') goesnames = [ 'YR', 'MO', 'DA', 'HHMM', 'JDay', 'Secs', 'Short', 'Long' ] self.goesdat = Table(names=goesnames) #loop over all day information and add to large array for m in goesfil: temp = ascii.read(m, guess=True, comment='#', data_start=2, names=goesnames) self.goesdat = vstack([self.goesdat, temp]) #create datetime array self.goesdat['time_dt'] = [ datetime(int(i['YR']), int(i['MO']), int(i['DA'])) + dt(seconds=i['Secs']) for i in self.goesdat ] if self.wind: aceb = glob.glob(self.sdir + '/ace/*mag*txt') acep = glob.glob(self.sdir + '/ace/*swe*txt') aceb_names = [ 'YR', 'MO', 'DA', 'HHMM', 'JDay', 'Secs', 'S', 'Bx', 'By', 'Bz', 'Bt', 'Lat', 'Long' ] acep_names = [ 'YR', 'MO', 'DA', 'HHMM', 'JDay', 'Secs', 'S', 'Den', 'Speed', 'Temp' ] acebdat = Table(names=aceb_names) acepdat = Table(names=acep_names) #put B field in large array for m in aceb: temp = ascii.read(m, guess=True, comment='#', data_start=2, names=aceb_names) acebdat = vstack([acebdat, temp]) #put plasmag in large array for m in acep: temp = ascii.read(m, guess=True, comment='#', data_start=2, names=acep_names) acepdat = vstack([acepdat, temp]) self.aceadat = join(acepdat, acebdat, keys=['YR', 'MO', 'DA', 'HHMM']) #create datetime array self.aceadat['time_dt'] = [ datetime(int(i['YR']), int(i['MO']), int(i['DA'])) + dt(seconds=i['Secs_1']) for i in self.aceadat ] #download files locally if self.download: self.run_download() #use a local directory of files elif self.local: self.gather_local() else: self.scream() # use SDO archive to search
def setup_class(self): self.client = HelioviewerClient() self.sources = self.client.get_data_sources()
def build_timelist(YEAR, MONTH, DAY): times = [] for hours in range (0, 24): for minutes in xrange (0, 60, 12): times.append(datetime.datetime(YEAR, MONTH, DAY, hours, minutes, 00)) return times if __name__ == '__main__': year, month, day = get_date() timelist = build_timelist(year, month, day) hv = HelioviewerClient() #file = hv.download_png('2015/01/01', 6, "[SDO,AIA,AIA,304,1,100],[SDO,AIA,AIA,193,1,50],[SOHO,LASCO,C2,white-light,1,100],[SOHO,LASCO,C3,white-light,1,100]", x0=0, y0=0, width=900, height=900) minutes = [] for minute in xrange(0, 60, 12): minutes.append(minute) for time in timelist: filenum = timelist.index(time) + 1 total = len(timelist) print("DOWNLOADING: " + str(time) + " --- " + str(filenum) + "/" + str(total)) file = hv.download_png(time, 6, "[SDO,AIA,AIA,193,1,100],"\ "[SOHO,LASCO,C2,white-light,1,100]", directory="./downloaded", x0=0, y0=0, width=2000, height=2000, watermark=False )
def setup_class(self): self.client = HelioviewerClient() self.sources = self.client.get_data_sources()
from sunpy.net.helioviewer import HelioviewerClient hv = HelioviewerClient() hv.download_png("2099/01/01", 6, "[SDO,AIA,AIA,304,1,100],[SDO,AIA,AIA,193,1,50],"+ "[SOHO,LASCO,C2,white-light,1,100]", x0=0, y0=0, width=768, height=768)
# # Download a set of jp2 files from helioviewer # import os import datetime import astropy.units as u from sunpy.time import parse_time from sunpy.net.helioviewer import HelioviewerClient cadence = 28 * u.day start_time = parse_time('2010/10/01') end_time = parse_time('2017/02/01') hv = HelioviewerClient() observatory = 'SDO' instrument = 'AIA' detector = 'AIA' measurements = ['94', '131', '171', '193', '211', '304', '335', '1600', '1700', '4500'] #measurements = ['193', '211', '335', '1600', '1700', '4500'] storage = os.path.expanduser('~/Data/hvp/aia_color_correction') if not os.path.isdir(storage): os.makedirs(storage) for measurement in measurements: # Make the storage directory storage_measurement = os.path.join(storage, measurement) if not os.path.isdir(storage_measurement): os.makedirs(storage_measurement)
# conda install -c sunpy glymur # pip install sunpy zeep drms sqlalchemy import sunpy.map from sunpy.database.tables import display_entries from sunpy.net import Fido, attrs as a from sunpy.database import Database from sunpy.io.file_tools import read_file from sunpy.timeseries import TimeSeries from sunpy.data.sample import NOAAINDICES_TIMESERIES as noaa_ind import sunpy.data.sample as sample_data # We can use the Helioviewer to get a Jpeg of the Sun from today: from sunpy.net.helioviewer import HelioviewerClient hv = HelioviewerClient() sun = hv.download_jp2('2020/05/06', observatory="SDO", instrument="HMI", measurement="continuum") hmiC = sunpy.map.Map(sun) hmiC.peek() # Here we have specified the telescope, SDO, the instrument/camera, HMI, and the measurement to plot, continuum. # To view the full list of options we can print the data sources available to us like this: print(hv.data_sources) # Let's clean up this plot and make it the orange/yellow colour we see visually. fig = plt.figure(1) ax = plt.subplot(111, projection=hmiC) ax.set_axis_off() cmap = plt.get_cmap('afmhot')
def download_images(c1, c2, craft, c1_hvr, c2_hvr, cme_root): """Download the COR1 and COR2 fits files for the frame nearest tm, to get coords and do distance calc. Download several pngs around the event. """ # Open up a VSO client and a Helioviewer Client vsoclient = vso.VSOClient() hv = HelioviewerClient() # Loop over the events, make event directory, download closest fits file # and several pngs. for i in range(len(c1)): print 'length of c1' print len(c1) print i cme_dir = cme_root + r'\cme_' + '{0:02d}'.format(i + 1) if not os.path.exists(cme_dir): os.makedirs(cme_dir) ####################################################################### # Search for COR1 data in +/- 30min window around event tm1 dt = pd.Timedelta(30, 'm') tl = [(c1['tm'][i] - dt).isoformat(), (c1['tm'][i] + dt).isoformat()] # Query VSO to find what files available qr = vsoclient.query(vso.attrs.Time(tl[0], tl[1]), vso.attrs.Instrument('cor1'), vso.attrs.Source(craft)) # Take out values that are not 0deg polarised q = 0 while q <= len(qr) - 1: tpe = qr[q]['info'].split(';')[3].strip() if tpe == '0deg.': q = q + 1 else: qr.pop(q) # Find closest mathced in time # Get datetimes of the query resutls times = np.array([pd.to_datetime(x['time']['start']) for x in qr]) # Remove querys before the closest match q = 0 while q < np.argmin(np.abs(times - c1['tm'][i])): qr.pop(0) q = q + 1 # Remove querys after the closest match while len(qr) > 1: qr.pop(1) # Download best matched file vsoclient.get(qr, path=cme_dir + r"\{file}").wait() for t in times: hv.download_png(t.isoformat(), 7.5, c1_hvr, x0=0, y0=0, width=1024, height=1024, directory=cme_dir, watermark=True) ################################################################### # Search for COR2 data around tm2 dt = pd.Timedelta(90, 'm') tl = [(c2['tm'][i] - dt).isoformat(), (c2['tm'][i] + dt).isoformat()] qr = vsoclient.query(vso.attrs.Time(tl[0], tl[1]), vso.attrs.Instrument('cor2'), vso.attrs.Source(craft)) # Take out values not 2048x2048 double exposures q = 0 while q <= len(qr) - 1: tpe = qr[q]['info'].split(';')[2].strip() sze = qr[q]['info'].split(';')[-1].strip() if tpe == 'DOUBLE' and sze == '2048x2048': q = q + 1 else: qr.pop(q) # Find closest mathced in time # Get datetimes of the query resutls times = np.array([pd.to_datetime(x['time']['start']) for x in qr]) # Remove querys before the closest match q = 0 while q < np.argmin(np.abs(times - c2['tm'][i])): qr.pop(0) q = q + 1 # Remove querys after the closest match while len(qr) > 1: qr.pop(1) # Download best matched file vsoclient.get(qr, path=cme_dir + r"\{file}").wait() # Use the query times to download helioviewer PNGS for t in times: hv.download_png(t.isoformat(), 14.7, c2_hvr, x0=0, y0=0, width=2048, height=2048, directory=cme_dir, watermark=True) ################################################################### # Now use the fits files to work out the mid point distance and # update the arrays c1_file = glob.glob(cme_dir + r'\*c1*.fts') rb, rm = calc_radial_distance(c1_file, cme_root) c1['rb'][i] = rb c1['rm'][i] = rm # Repeat for COR2 c2_file = glob.glob(cme_dir + r'\*c2*.fts') rb, rm = calc_radial_distance(c2_file, cme_root) c2['rb'][i] = rb c2['rm'][i] = rm return c1, c2
class RGBCompositeImageApp(QtGui.QMainWindow): def __init__(self): QtGui.QMainWindow.__init__(self) self.ui = Ui_RGBComposite.Ui_RGBComposite() self.ui.setupUi(self) # Helioviewer client self._hv = HelioviewerClient() self._datasources = None # Loaded images self.red = None self.green = None self.blue = None # Color channel weights self._weights = [1.0, 1.0, 1.0] # Setup UI self._load_data_sources() # Load initial data self._load_defaults() # Initialize event handlers self._initEvents() def _load_data_sources(self): """Downloads and displays latest images for default wavelengths""" self._datasources = self._hv.get_data_sources()["SDO"]["AIA"]["AIA"] sorted_datasources = sorted(self._datasources, key=int) for wl in sorted_datasources: self.ui.redWavelengthSelect.addItem(wl, self._datasources[wl]) self.ui.greenWavelengthSelect.addItem(wl, self._datasources[wl]) self.ui.blueWavelengthSelect.addItem(wl, self._datasources[wl]) # Default wavelengths: 304, 193, 171 self.ui.redWavelengthSelect.setCurrentIndex(5) self.ui.greenWavelengthSelect.setCurrentIndex(3) self.ui.blueWavelengthSelect.setCurrentIndex(2) def _load_defaults(self): """Load initial images""" now = datetime.datetime.utcnow() self.ui.dateTimeEdit.setDateTime(now) r = self._hv.download_jp2(now, sourceId=self._datasources["304"]["sourceId"]) g = self._hv.download_jp2(now, sourceId=self._datasources["193"]["sourceId"]) b = self._hv.download_jp2(now, sourceId=self._datasources["171"]["sourceId"]) self.red = sunpy.map.Map(r) self.green = sunpy.map.Map(g) self.blue = sunpy.map.Map(b) self._updateRedPreview() self._updateGreenPreview() self._updateBluePreview() self._createCompositeImage() def _updateCompositeImage(self): """Updates the composite image""" # Remove old composite rgb = RGBCompositeMap(self.red, self.green, self.blue) self.ui.compositeContainer.removeWidget(self.ui.compositeImage) self.ui.compositeImage.close() # Plot new one self.ui.compositeImage = RGBCompositePlot(rgb, 512, 512) self.ui.compositeImage.set_rgb_weights(self._weights) self.ui.compositeContainer.addWidget(self.ui.compositeImage, 1) self.ui.compositeContainer.update() def _createCompositeImage(self): """Creates an initial composite image plot""" rgb = RGBCompositeMap(self.red, self.green, self.blue) self.ui.compositeContainer.removeWidget(self.ui.compositePlaceholder) self.ui.compositePlaceholder.close() self.ui.compositeImage = RGBCompositePlot(rgb, 512, 512) self.ui.compositeContainer.addWidget(self.ui.compositeImage, 1) self.ui.compositeContainer.update() def _updateRedPreview(self): """Updates the red preview image""" if hasattr(self.ui, "redPreviewImage"): self.ui.redPreview.removeWidget(self.ui.redPreviewImage) self.ui.redPreviewImage.close() else: self.ui.redPreview.removeWidget(self.ui.redPlaceholder) self.ui.redPlaceholder.close() self.ui.redPreviewImage = SunPyPlot(self.red, 256, 256) # cmap=cm.Reds_r self.ui.redPreview.addWidget(self.ui.redPreviewImage, 1) self.ui.redPreview.update() def _updateGreenPreview(self): """Updates the green preview image""" if hasattr(self.ui, "greenPreviewImage"): self.ui.greenPreview.removeWidget(self.ui.greenPreviewImage) self.ui.greenPreviewImage.close() else: self.ui.greenPreview.removeWidget(self.ui.greenPlaceholder) self.ui.greenPlaceholder.close() self.ui.greenPreviewImage = SunPyPlot(self.green, 256, 256) # cmap=cm.Greens_r self.ui.greenPreview.addWidget(self.ui.greenPreviewImage, 1) self.ui.greenPreview.update() def _updateBluePreview(self): """Updates the blue preview image""" if hasattr(self.ui, "bluePreviewImage"): self.ui.bluePreview.removeWidget(self.ui.bluePreviewImage) self.ui.bluePreviewImage.close() else: self.ui.bluePreview.removeWidget(self.ui.bluePlaceholder) self.ui.bluePlaceholder.close() self.ui.bluePreviewImage = SunPyPlot(self.blue, 256, 256) # cmap=cm.Blues_r self.ui.bluePreview.addWidget(self.ui.bluePreviewImage, 1) self.ui.bluePreview.update() def _initEvents(self): """Initialize event handlers""" self.connect(self.ui.redWeightSlider, QtCore.SIGNAL("valueChanged(int)"), self.onRedWeightChange) self.connect(self.ui.greenWeightSlider, QtCore.SIGNAL("valueChanged(int)"), self.onGreenWeightChange) self.connect(self.ui.blueWeightSlider, QtCore.SIGNAL("valueChanged(int)"), self.onBlueWeightChange) self.connect(self.ui.dateTimeEdit, QtCore.SIGNAL("dateTimeChanged(QDateTime)"), self.onDateChange) self.connect(self.ui.dateTimeEdit, QtCore.SIGNAL("dateTimeChanged(QDateTime)"), self.onDateChange) self.connect(self.ui.actionSave, QtCore.SIGNAL("activated()"), self.onSaveClick) def onRedWeightChange(self, value): """Red channel weight changed""" self._weights[0] = value / 100.0 self.ui.compositeImage.set_rgb_weights((self._weights)) def onGreenWeightChange(self, value): """Green channel weight changed""" self._weights[1] = value / 100.0 self.ui.compositeImage.set_rgb_weights((self._weights)) def onBlueWeightChange(self, value): """Blue channel weight changed""" self._weights[2] = value / 100.0 self.ui.compositeImage.set_rgb_weights((self._weights)) def onDateChange(self, qdatetime): """Updates the images when the date is changed""" dt = qdatetime.toPyDateTime() r = self._hv.download_jp2(dt, sourceId=self._datasources["304"]["sourceId"]) g = self._hv.download_jp2(dt, sourceId=self._datasources["193"]["sourceId"]) b = self._hv.download_jp2(dt, sourceId=self._datasources["171"]["sourceId"]) self.red = sunpy.map.Map(r) self.green = sunpy.map.Map(g) self.blue = sunpy.map.Map(b) self._updateRedPreview() self._updateGreenPreview() self._updateBluePreview() self._updateCompositeImage() def onSaveClick(self): """Save the composite image""" filename = QtGui.QFileDialog.getSaveFileName(self, "Save image", "composite.png") self.ui.compositeImage.figure.savefig(str(filename))
#!/usr/bin/env python3 #129L Final Project Part 3 -- user customizable program to plot locations of CMEs and sunspots on corresponding images #import sunpy.map from sunpy.net.helioviewer import HelioviewerClient from matplotlib.image import imread import matplotlib.pyplot as plt from matplotlib import patches hv = HelioviewerClient() DAT = input('Date yyyy/m/d: ') #IMRES = input('Image Resolution in arcseconds/pixel: ') SRCID = input('Data Source ID: ') #VIS = input('Visibility: ') #OP = input('Opacity: ') XFOC = input('Specify x-coord: ') YFOC = input('Specify y-coord: ') ##include image size in a function, make dict for source ids, make optional args for composite images IN = [SRCID, XFOC, YFOC] FLIN = list(map(float, IN)) imgfile = hv.download_png(DAT, 6.0, [FLIN[0], 1.0, 100.0], x0=FLIN[1], y0=FLIN[2], width=512, height=512)
# # Code to download JP2 files # from sunpy.net.helioviewer import HelioviewerClient from sunpy.map import Map import os hv = HelioviewerClient() datasources = hv.get_data_sources() get_files = False directory = '/home/ireland/hv/sunpy_hv_test_images/' #directory = '/home/ireland/hv/TRACE_test_images/' # print a list of datasources and their associated ids files = [] if get_files: for observatory, instruments in datasources.items(): for inst, detectors in instruments.items(): for det, measurements in detectors.items(): for meas, params in measurements.items(): print("%s %s: %d" % (observatory, params['nickname'], params['sourceId'])) filepath = hv.download_jp2('2013/06/24 17:31:30', observatory=observatory, instrument=inst, detector=det, measurement=meas, directory=directory) files.append(filepath) else: flist = os.listdir(directory) for fl in flist:
try: t = time[0] except IndexError: print('Your search returned 0 results, please select another event') else: break print('Time span of event closest to start of selected interval: ', time[0]) ##Section2 -- setting up server request to Helioviewer.org that returns image of the sun nearest to requested event start time. User chooses which data source (instrument/detector) to obtain image from using the source ID. Each source has a unique imaging wavelength. timex = time[0][0] searchtime = timex[:timex.find('T')] date = searchtime.replace('-', '/') hv = HelioviewerClient() print( 'List of Observatories: [sourceID]:\n SDO HMI Mag: 19 \n SDO HMI Int: 18 \n SDO AIA 4500: 17 \n SDO AIA 94: 8 \n SDO AIA 131: 9 \n SDO AIA 335: 14 \n SDO AIA 171: 10 \n SDO AIA 304: 13 \n SDO AIA 1600: 15 \n SDO AIA 211: 12 \n SDO AIA 1700: 16 \n SDO AIA 193: 11 \n STEREO_B COR2-B: 31 \n STEREO_B EUVI-B 304: 27 \n STEREO_B EUVI-B 284: 26 \n STEREO_B EUVI-B 195: 25 \n STEREO_B EUVI-B 171: 24 \n STEREO_B COR1-B: 30 \n Yohkoh SXT white-light: 35 \n Yohkoh SXT thin-Al: 34 \n Yohkoh SXT AlMgMn: 33 \n SOHO MDI Mag: 6 \n SOHO MDI Int: 7 \n SOHO LASCO C3: 5 \n SOHO LASCO C2: 4 \n SOHO EIT 304: 3 \n SOHO EIT 284: 2 \n SOHO EIT 195: 1 \n SOHO EIT 171: 0 \n PROBA2 SWAP 174: 32 \n STEREO_A COR2-A: 29 \n STEREO_A EUVI-A 304: 23 \n STEREO_A EUVI-A 284: 22 \n STEREO_A EUVI-A 195: 21 \n STEREO_A EUVI-A 171: 20 \n STEREO_A COR1-A: 28' ) id_list = [ '19', '18', '17', '8', '9', '14', '10', '13', '15', '12', '16', '11', '31', '27', '26', '25', '24', '30', '35', '34', '33', '6', '7', '5', '4', '3', '2', '1', '0', '32', '29', '23', '22', '21', '20', '28' ] source = None while source not in id_list: source = input('Please input an available numerical data source ID: ')
def _is_online(hv: HelioviewerClient): try: return hv.is_online() except: return False
# -*- coding: utf-8 -*- """ Created on Tue Jan 21 11:05:34 2020 @author: ventas from sunpy.net.helioviewer import HelioviewerClient from sunpy.map import Map import matplotlib.pyplot as plt hv = HelioviewerClient() file = hv.download_jp2('2012/01/01', observatory="SDO", instrument="HMI", measurement="304", Source_id=19) #('SDO', 'HMI', None, 'magnetogram'): 19 aia = Map(file) aia.peek() """ from sunpy.net.helioviewer import HelioviewerClient #from astropy.units import Quantity #from sunpy.map import Map hv = HelioviewerClient() data_sources = hv.get_data_sources() filepath = hv.download_jp2('2012/07/05 00:30:00', observatory='SDO', instrument='HMI', measurement='magnetogram') #hmi = Map(filepath) #xrange = Quantity([200, 550], 'arcsec') #yrange = Quantity([-400, 200], 'arcsec') #hmi.submap(xrange, yrange).peek()
""" Helioviewer Client tests """ from __future__ import absolute_import #pylint: disable=C0103,R0904,W0201,W0212,W0232,E1103 import sunpy import sunpy.map import pytest from sunpy.net.helioviewer import HelioviewerClient # If server is not accessible, skip Helioviewer tests client = HelioviewerClient() if not client.is_online(): __SKIP_TESTS__ = True print("Skipping Helioviewer.org tests (server inaccessible)") else: __SKIP_TESTS__ = False class TestHelioviewerClient: """Tests the Helioviewer.org API Client class""" def setup_class(self): self.client = client self.sources = self.client.get_data_sources() def teardown_class(self): self.client = None @pytest.mark.skipif("__SKIP_TESTS__ is True") def test_get_datasources(self): """Makes sure datasource query returns a valid result and source id
# # Download a set of jp2 files from helioviewer # import os import datetime import astropy.units as u from sunpy.time import parse_time from sunpy.net.helioviewer import HelioviewerClient cadence = 28 * u.day start_time = parse_time('2010/10/01') end_time = parse_time('2017/02/01') hv = HelioviewerClient() observatory = 'SDO' instrument = 'AIA' detector = 'AIA' measurements = [ '94', '131', '171', '193', '211', '304', '335', '1600', '1700', '4500' ] #measurements = ['193', '211', '335', '1600', '1700', '4500'] storage = os.path.expanduser('~/Data/hvp/aia_color_correction') if not os.path.isdir(storage): os.makedirs(storage) for measurement in measurements: # Make the storage directory storage_measurement = os.path.join(storage, measurement) if not os.path.isdir(storage_measurement): os.makedirs(storage_measurement)
class RGBCompositeImageApp(QtGui.QMainWindow): def __init__(self): QtGui.QMainWindow.__init__(self) self.ui = Ui_RGBComposite.Ui_RGBComposite() self.ui.setupUi(self) # Helioviewer client self._hv = HelioviewerClient() self._datasources = None # Loaded images self.red = None self.green = None self.blue = None # Color channel weights self._weights = [1., 1., 1.] # Setup UI self._load_data_sources() # Load initial data self._load_defaults() # Initialize event handlers self._initEvents() def _load_data_sources(self): """Downloads and displays latest images for default wavelengths""" self._datasources = self._hv.get_data_sources()['SDO']['AIA']['AIA'] sorted_datasources = sorted(self._datasources, key=int) for wl in sorted_datasources: self.ui.redWavelengthSelect.addItem(wl, self._datasources[wl]) self.ui.greenWavelengthSelect.addItem(wl, self._datasources[wl]) self.ui.blueWavelengthSelect.addItem(wl, self._datasources[wl]) # Default wavelengths: 304, 193, 171 self.ui.redWavelengthSelect.setCurrentIndex(5) self.ui.greenWavelengthSelect.setCurrentIndex(3) self.ui.blueWavelengthSelect.setCurrentIndex(2) def _load_defaults(self): """Load initial images""" now = datetime.datetime.utcnow() self.ui.dateTimeEdit.setDateTime(now) r = self._hv.download_jp2( now, sourceId=self._datasources['304']['sourceId']) g = self._hv.download_jp2( now, sourceId=self._datasources['193']['sourceId']) b = self._hv.download_jp2( now, sourceId=self._datasources['171']['sourceId']) self.red = sunpy.map.Map(r) self.green = sunpy.map.Map(g) self.blue = sunpy.map.Map(b) self._updateRedPreview() self._updateGreenPreview() self._updateBluePreview() self._createCompositeImage() def _updateCompositeImage(self): """Updates the composite image""" # Remove old composite rgb = RGBCompositeMap(self.red, self.green, self.blue) self.ui.compositeContainer.removeWidget(self.ui.compositeImage) self.ui.compositeImage.close() # Plot new one self.ui.compositeImage = RGBCompositePlot(rgb, 512, 512) self.ui.compositeImage.set_rgb_weights(self._weights) self.ui.compositeContainer.addWidget(self.ui.compositeImage, 1) self.ui.compositeContainer.update() def _createCompositeImage(self): """Creates an initial composite image plot""" rgb = RGBCompositeMap(self.red, self.green, self.blue) self.ui.compositeContainer.removeWidget(self.ui.compositePlaceholder) self.ui.compositePlaceholder.close() self.ui.compositeImage = RGBCompositePlot(rgb, 512, 512) self.ui.compositeContainer.addWidget(self.ui.compositeImage, 1) self.ui.compositeContainer.update() def _updateRedPreview(self): """Updates the red preview image""" if hasattr(self.ui, "redPreviewImage"): self.ui.redPreview.removeWidget(self.ui.redPreviewImage) self.ui.redPreviewImage.close() else: self.ui.redPreview.removeWidget(self.ui.redPlaceholder) self.ui.redPlaceholder.close() self.ui.redPreviewImage = SunPyPlot(self.red, 256, 256) #cmap=cm.Reds_r self.ui.redPreview.addWidget(self.ui.redPreviewImage, 1) self.ui.redPreview.update() def _updateGreenPreview(self): """Updates the green preview image""" if hasattr(self.ui, "greenPreviewImage"): self.ui.greenPreview.removeWidget(self.ui.greenPreviewImage) self.ui.greenPreviewImage.close() else: self.ui.greenPreview.removeWidget(self.ui.greenPlaceholder) self.ui.greenPlaceholder.close() self.ui.greenPreviewImage = SunPyPlot(self.green, 256, 256) #cmap=cm.Greens_r self.ui.greenPreview.addWidget(self.ui.greenPreviewImage, 1) self.ui.greenPreview.update() def _updateBluePreview(self): """Updates the blue preview image""" if hasattr(self.ui, "bluePreviewImage"): self.ui.bluePreview.removeWidget(self.ui.bluePreviewImage) self.ui.bluePreviewImage.close() else: self.ui.bluePreview.removeWidget(self.ui.bluePlaceholder) self.ui.bluePlaceholder.close() self.ui.bluePreviewImage = SunPyPlot(self.blue, 256, 256) #cmap=cm.Blues_r self.ui.bluePreview.addWidget(self.ui.bluePreviewImage, 1) self.ui.bluePreview.update() def _initEvents(self): """Initialize event handlers""" self.connect(self.ui.redWeightSlider, QtCore.SIGNAL('valueChanged(int)'), self.onRedWeightChange) self.connect(self.ui.greenWeightSlider, QtCore.SIGNAL('valueChanged(int)'), self.onGreenWeightChange) self.connect(self.ui.blueWeightSlider, QtCore.SIGNAL('valueChanged(int)'), self.onBlueWeightChange) self.connect(self.ui.dateTimeEdit, QtCore.SIGNAL('dateTimeChanged(QDateTime)'), self.onDateChange) self.connect(self.ui.dateTimeEdit, QtCore.SIGNAL('dateTimeChanged(QDateTime)'), self.onDateChange) self.connect(self.ui.actionSave, QtCore.SIGNAL('activated()'), self.onSaveClick) def onRedWeightChange(self, value): """Red channel weight changed""" self._weights[0] = value / 100. self.ui.compositeImage.set_rgb_weights((self._weights)) def onGreenWeightChange(self, value): """Green channel weight changed""" self._weights[1] = value / 100. self.ui.compositeImage.set_rgb_weights((self._weights)) def onBlueWeightChange(self, value): """Blue channel weight changed""" self._weights[2] = value / 100. self.ui.compositeImage.set_rgb_weights((self._weights)) def onDateChange(self, qdatetime): """Updates the images when the date is changed""" dt = qdatetime.toPyDateTime() r = self._hv.download_jp2( dt, sourceId=self._datasources['304']['sourceId']) g = self._hv.download_jp2( dt, sourceId=self._datasources['193']['sourceId']) b = self._hv.download_jp2( dt, sourceId=self._datasources['171']['sourceId']) self.red = sunpy.map.Map(r) self.green = sunpy.map.Map(g) self.blue = sunpy.map.Map(b) self._updateRedPreview() self._updateGreenPreview() self._updateBluePreview() self._updateCompositeImage() def onSaveClick(self): """Save the composite image""" filename = QtGui.QFileDialog.getSaveFileName(self, "Save image", "composite.png") self.ui.compositeImage.figure.savefig(str(filename))
img = sunpy.map.Map(filep) #Level0 quality flag equals 0 (0 means no issues) lev0 = img.meta['quallev0'] == 0 #check level1 bitwise keywords (http://jsoc.stanford.edu/doc/keywords/AIA/AIA02840_K_AIA-SDO_FITS_Keyword_Document.pdf) lev1 = np.binary_repr( img.meta['quality']) == '1000000000000000000000000000000' #check to see if it is a calibration image #This keyword changed after AIA failure # calb = np.binary_repr(img.meta['aiftsid']) == '1010000000000000' #check that both levels pass and it is not a calibration file check = ((lev0) & (lev1)) # & (calb)) return check, img hv = HelioviewerClient() #datasources = hv.get_data_sources() #Only thing to edit if someone else takes over weekly weather #running in subdirectory so this step is not need (Prchlik J. 2017/03/03) #stard = '/Volumes/Pegasus/jprchlik/weekly_weather/' now = datetime.utcnow() #day of weekly weather (currently Tuesday) wday = 1 #dimensions of the image w0 = 1900 h0 = 1144 #video wall ratio
""" Helioviewer Client tests """ from __future__ import absolute_import #pylint: disable=C0103,R0904,W0201,W0212,W0232,E1103 import sunpy import sunpy.map import pytest from sunpy.net.helioviewer import HelioviewerClient from sunpy.tests.helpers import skip_glymur # If server is not accessible, skip Helioviewer tests client = HelioviewerClient() if not client.is_online(): __SKIP_TESTS__ = True print("Skipping Helioviewer.org tests (server inaccessible)") else: __SKIP_TESTS__ = False class TestHelioviewerClient: """Tests the Helioviewer.org API Client class""" def setup_class(self): self.client = client self.sources = self.client.get_data_sources() def teardown_class(self): self.client = None
from sunpy.net.helioviewer import HelioviewerClient hv = HelioviewerClient() hv.download_png("2099/01/01", 6, "[SDO,AIA,AIA,304,1,100],[SDO,AIA,AIA,193,1,50]," + "[SOHO,LASCO,C2,white-light,1,100]", x0=0, y0=0, width=768, height=768)