def __init__(self, *args, **kwargs): """ Create a CompositeMap Parameters ---------- Maps: SunPy Maps A sequence of maps """ self._maps = expand_list(args) for m in self._maps: if not isinstance(m, GenericMap): raise ValueError( 'CompositeMap expects pre-constructed map objects.') # Default alpha and zorder values alphas = [1] * len(self._maps) zorders = range(0, 10 * len(self._maps), 10) levels = [False] * len(self._maps) # Set z-order and alpha values for the map for i, m in enumerate(self._maps): m.zorder = zorders[i] m.alpha = alphas[i] m.levels = levels[i]
def _parse_args(self, *args, silence_errors=False, **kwargs): """ Parses an args list into data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * data, wcs object in a tuple * data, wcs object not in a tuple * filename, as a str or pathlib.Path, which will be read * directory, as a str or pathlib.Path, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Examples -------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ # Account for nested lists of items args = expand_list(args) # Sanitise the input so that each 'type' of input corresponds to a different # class, so single dispatch can be used later nargs = len(args) i = 0 while i < nargs: arg = args[i] if isinstance(arg, SUPPORTED_ARRAY_TYPES): # The next two items are data and a header data = args.pop(i) header = args.pop(i) args.insert(i, (data, header)) nargs -= 1 elif isinstance(arg, str) and is_url(arg): # Repalce URL string with a Request object to dispatch on later args[i] = Request(arg) elif possibly_a_path(arg): # Repalce path strings with Path objects args[i] = pathlib.Path(arg) i += 1 # Parse the arguments # Note that this list can also contain GenericMaps if they are directly given to the factory data_header_pairs = [] for arg in args: try: data_header_pairs += self._parse_arg(arg, **kwargs) except NoMapsInFileError as e: if not silence_errors: raise warn_user( f"One of the arguments failed to parse with error: {e}") return data_header_pairs
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Renaming mapcube functionality to mapsequence warnings.warn("Deprecated in favor of MapSequence. MapSequence has the same functionality as MapCube.", SunpyDeprecationWarning, stacklevel=2) # Hack to get around Python 2.x not backporting PEP 3102. sortby = kwargs.pop('sortby', 'date') derotate = kwargs.pop('derotate', False) self.maps = expand_list(args) for m in self.maps: if not isinstance(m, GenericMap): raise ValueError( 'MapCube expects pre-constructed map objects.') # Optionally sort data if sortby is not None: if sortby is 'date': self.maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") if derotate: self._derotate()
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Hack to get around Python 2.x not backporting PEP 3102. orderby = kwargs.pop('orderby', 'date') derotate = kwargs.pop('derotate', False) self.ref_index = kwargs.pop('reference_index', 0) maps = expand_list(args) for m in maps: if not isinstance(m, GenericMap): raise ValueError( 'MapCubed expects pre-constructed map objects.') maps.sort(key=self._sort_by_date()) # test if all maps have the same shape if not np.all( [m.data.shape == maps[self.ref_index].data.shape for m in maps]): raise ValueError("All Map data must have the same dimensions") # test if all maps have the same scale if not np.all([m.scale == maps[self.ref_index].scale for m in maps]): raise ValueError("All Map data must have the same scale") self.data = np.zeros((maps[self.ref_index].data.shape[0], maps[self.ref_index].data.shape[1], len(maps)), dtype=maps[self.ref_index].data.dtype) for i, m in enumerate(maps): self.data[:, :, i] = m.data self._meta = [] for i, m in enumerate(maps): self._meta.append(m.meta)
def __init__(self, map3D, *args, **kwargs): # Use all the user parameters self.maps_list = map3D + expand_list(args) self.benchmark = kwargs.get('benchmark', 0) # Defaults to the first vector field in the list self.normalise = kwargs.get('normalise', False) # The table to store the test results self.results = Table(names=('extrapolator routine', 'extrapolation duration', 'fig of merit 1'), meta={'name': '3D field comparison table'}, dtype=('S24', 'f8', 'f8')) t['time (ave)'].unit = u.s # An empty table for the results: #N = len(self.maps_list) #t1, t2, t3, t4, t5, t6, t7 = [None] * N, [None] * N, [None] * N, [None] * N, [None] * N, [None] * N, [None] * N #self.results = Table([t1, t2, t3, t4, t5, t6, t7], names=('l-infinity norm', 'test 2', 'test 3', 'test 4', 'test 5', 'test 6', 'test 7'), meta={'name': 'Results Table'}) #self.results_normalised = Table([t1, t2, t3, t4, t5, t6, t7], names=('l-infinity norm', 'test 2', 'test 3', 'test 4', 'test 5', 'test 6', 'test 7'), meta={'name': 'Results Table'}) # Ensure that the input maps are all the same type and shape. for m in self.maps_list:#self.maps: # Check that this is a Map3D object. if not isinstance(m, Map3D): raise ValueError( 'Map3DComparer expects pre-constructed map3D objects.') # Compare the shape of this Map3D to the first in the Map3D list. if not m.data.shape == self.maps_list[0]: raise ValueError( 'Map3DComparer expects map3D objects with identical dimensions.')
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Renaming mapcube functionality to mapsequence warnings.warn( "Deprecated in favor of MapSequence. MapSequence has the same functionality as MapCube.", SunpyDeprecationWarning, stacklevel=2) # Hack to get around Python 2.x not backporting PEP 3102. sortby = kwargs.pop('sortby', 'date') derotate = kwargs.pop('derotate', False) self.maps = expand_list(args) for m in self.maps: if not isinstance(m, GenericMap): raise ValueError( 'MapCube expects pre-constructed map objects.') # Optionally sort data if sortby is not None: if sortby is 'date': self.maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") if derotate: self._derotate()
def __init__(self, map3D, *args, **kwargs): # Use all the user parameters self.maps_list = map3D + expand_list(args) self.benchmark = kwargs.get( 'benchmark', 0) # Defaults to the first vector field in the list self.normalise = kwargs.get('normalise', False) # The table to store the test results self.results = Table(names=('extrapolator routine', 'extrapolation duration', 'fig of merit 1'), meta={'name': '3D field comparison table'}, dtype=('S24', 'f8', 'f8')) t['time (ave)'].unit = u.s # An empty table for the results: #N = len(self.maps_list) #t1, t2, t3, t4, t5, t6, t7 = [None] * N, [None] * N, [None] * N, [None] * N, [None] * N, [None] * N, [None] * N #self.results = Table([t1, t2, t3, t4, t5, t6, t7], names=('l-infinity norm', 'test 2', 'test 3', 'test 4', 'test 5', 'test 6', 'test 7'), meta={'name': 'Results Table'}) #self.results_normalised = Table([t1, t2, t3, t4, t5, t6, t7], names=('l-infinity norm', 'test 2', 'test 3', 'test 4', 'test 5', 'test 6', 'test 7'), meta={'name': 'Results Table'}) # Ensure that the input maps are all the same type and shape. for m in self.maps_list: #self.maps: # Check that this is a Map3D object. if not isinstance(m, Map3D): raise ValueError( 'Map3DComparer expects pre-constructed map3D objects.') # Compare the shape of this Map3D to the first in the Map3D list. if not m.data.shape == self.maps_list[0]: raise ValueError( 'Map3DComparer expects map3D objects with identical dimensions.' )
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Hack to get around Python 2.x not backporting PEP 3102. sortby = kwargs.pop('sortby', 'date') coalign = kwargs.pop('coalign', False) derotate = kwargs.pop('derotate', False) self._maps = expand_list(args) for m in self._maps: if not isinstance(m, GenericMap): raise ValueError( 'CompositeMap expects pre-constructed map objects.') # Optionally sort data if sortby is not None: if sortby is 'date': self._maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") # Coalignment if coalign: if coalign == 'diff': self.coalign("diff") else: raise ValueError("That coalignment method is not supported") if derotate: self._derotate()
def _sanitise_args(self, args): """ Sanitise a list of args so that a single argument corresponds to either: - (data, header, units) tuple. - path-like `pathlib.Path` (e.g. a filename, directory, glob etc.). - `urllib.request.Request`. - `GenericTimeSeries`. """ # Account for nested lists of items. Simply outputs a single list of # items, nested lists are expanded to element level. args = expand_list(args) # Sanitise the input so that each 'type' of input corresponds to a different # class, so single dispatch can be used later i = 0 while i < len(args): arg = args[i] if isinstance(arg, (np.ndarray, Table, pd.DataFrame)): # Extract data and metadata # The next item is data data = args[i] meta = MetaDict() units = OrderedDict() if isinstance(data, Table): # We have an Astropy Table: data, new_meta, new_units = self._from_table(data) units.update(new_units) meta.update(new_meta) elif isinstance(data, np.ndarray): # We have a numpy ndarray. We assume the first column is a dt index data = pd.DataFrame(data=data[:, 1:], index=Time(data[:, 0])) # The next two could be metadata or units for _ in range(2): j = i + 1 if j < len(args): arg = args[j] if self._is_units(arg): units.update(arg) args.pop(j) elif self._is_metadata(arg): meta.update(self._parse_meta(arg)) args.pop(j) args[i] = (data, meta, units) elif isinstance(arg, str) and is_url(arg): args[i] = Request(arg) elif possibly_a_path(arg): args[i] = pathlib.Path(arg) i += 1 return args
def __init__(self, *args, **kwargs): # Hack to get around Python 2.x not backporting PEP 3102. #sortby = kwargs.pop('sortby', 'date') #derotate = kwargs.pop('derotate', False) self.maps = expand_list(args) for m in self.maps: if not isinstance(m, Map3D): raise ValueError( 'CompositeMap expects pre-constructed map objects.')
def __init__(self, *args, sortby='date', derotate=False, **kwargs): """Creates a new Map instance""" self.maps = expand_list(args) for m in self.maps: if not isinstance(m, GenericMap): raise ValueError('MapSequence expects pre-constructed map objects.') # Optionally sort data if sortby is not None: if sortby == 'date': self.maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") if derotate: self._derotate()
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Hack to get around Python 2.x not backporting PEP 3102. sortby = kwargs.pop("sortby", "date") derotate = kwargs.pop("derotate", False) self.maps = expand_list(args) for m in self.maps: if not isinstance(m, GenericMap): raise ValueError("MapCube expects pre-constructed map objects.") # Optionally sort data if sortby is not None: if sortby is "date": self.maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") if derotate: self._derotate()
def __init__(self, *args, **kwargs): """Creates a new Map instance""" # Hack to get around Python 2.x not backporting PEP 3102. sortby = kwargs.pop('sortby', 'date') derotate = kwargs.pop('derotate', False) self.maps = expand_list(args) for m in self.maps: if not isinstance(m, GenericMap): raise ValueError( 'MapSequence expects pre-constructed map objects.') # Optionally sort data if sortby is not None: if sortby is 'date': self.maps.sort(key=self._sort_by_date()) else: raise ValueError("Only sort by date is supported") if derotate: self._derotate()
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * data, wcs object in a tuple * data, wcs object not in a tuple * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_pairs = list() already_maps = list() # Account for nested lists of items args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header or data-WCS pair if isinstance(arg, SUPPORTED_ARRAY_TYPES): arg_header = args[i+1] if isinstance(arg_header, WCS): arg_header = args[i+1].to_header() if self._validate_meta(arg_header): pair = (args[i], OrderedDict(arg_header)) data_header_pairs.append(pair) i += 1 # an extra increment to account for the data-header pairing # File name elif (isinstance(arg, six.string_types) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # Directory elif (isinstance(arg, six.string_types) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Glob elif (isinstance(arg, six.string_types) and '*' in arg): files = glob.glob(os.path.expanduser(arg)) for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Already a Map elif isinstance(arg, GenericMap): already_maps.append(arg) # A URL elif (isinstance(arg, six.string_types) and _is_url(arg)): url = arg path = download_file(url, get_and_create_download_dir()) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # A database Entry elif isinstance(arg, DatabaseEntry): data_header_pairs += self._read_file(arg.path, **kwargs) else: raise ValueError("File not found or invalid input") i += 1 # TODO: # In the end, if there are already maps it should be put in the same # order as the input, currently they are not. return data_header_pairs, already_maps
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_pairs = list() already_maps = list() # Account for nested lists of items args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header pair in a tuple if ((type(arg) in [tuple, list]) and len(arg) == 2 and isinstance(arg[0],np.ndarray) and isinstance(arg[1],dict)): data_header_pairs.append(arg) # Data-header pair not in a tuple elif (isinstance(arg, np.ndarray) and isinstance(args[i+1],dict)): pair = (args[i], args[i+1]) data_header_pairs.append(pair) i += 1 # an extra increment to account for the data-header pairing # File name elif (isinstance(arg,basestring) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # Directory elif (isinstance(arg,basestring) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Glob elif (isinstance(arg,basestring) and '*' in arg): files = glob.glob( os.path.expanduser(arg) ) for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Already a Map elif isinstance(arg, GenericMap): already_maps.append(arg) # A URL elif (isinstance(arg,basestring) and _is_url(arg)): default_dir = sunpy.config.get("downloads", "download_dir") url = arg path = download_file(url, default_dir) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # A database Entry elif isinstance(arg, DatabaseEntry): data_header_pairs += self._read_file(arg.path, **kwargs) else: raise ValueError("File not found or invalid input") i += 1 #TODO: # In the end, if there are aleady maps it should be put in the same # order as the input, currently they are not. return data_header_pairs, already_maps
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * data, wcs object in a tuple * data, wcs object not in a tuple * filename, as a str or pathlib.Path, which will be read * directory, as a str or pathlib.Path, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_pairs = list() already_maps = list() # Account for nested lists of items args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header or data-WCS pair if isinstance(arg, SUPPORTED_ARRAY_TYPES): arg_header = args[i+1] if isinstance(arg_header, WCS): arg_header = args[i+1].to_header() if self._validate_meta(arg_header): pair = (args[i], OrderedDict(arg_header)) data_header_pairs.append(pair) i += 1 # an extra increment to account for the data-header pairing # A database Entry elif isinstance(arg, DatabaseEntryType): data_header_pairs += self._read_file(arg.path, **kwargs) # Already a Map elif isinstance(arg, GenericMap): already_maps.append(arg) # URL elif isinstance(arg, str) and _is_url(arg): url = arg path = str(cache.download(url).absolute()) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # File system path (file or directory or glob) elif _possibly_a_path(arg): path = pathlib.Path(arg).expanduser() if _is_file(path): pairs = self._read_file(path, **kwargs) data_header_pairs += pairs elif _is_dir(path): for afile in sorted(path.glob('*')): data_header_pairs += self._read_file(afile, **kwargs) elif glob.glob(os.path.expanduser(arg)): for afile in sorted(glob.glob(os.path.expanduser(arg))): data_header_pairs += self._read_file(afile, **kwargs) else: raise ValueError(f'Did not find any files at {arg}') else: raise ValueError(f"Invalid input: {arg}") i += 1 # TODO: # In the end, if there are already maps it should be put in the same # order as the input, currently they are not. return data_header_pairs, already_maps
def _parse_args(self, *args, **kwargs): """ Parses an `args` list for data-header pairs. `args` can contain any mixture of the following entries: * tuples of (data, header, unit) (1) * data, header not in a tuple (1) * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. (1) header/unit are optional and in either order, but data should be the first entry in each group. Examples -------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_unit_tuples = list() data_header_pairs = list() already_timeseries = list() filepaths = list() # Account for nested lists of items. Simply outputs a single list of # items, nested lists are expanded to element level. args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header pair in a tuple if (isinstance(arg, (np.ndarray, Table, pd.DataFrame))): # and self._validate_meta(args[i+1])): # Assume a Pandas Dataframe is given data = arg units = OrderedDict() meta = MetaDict() # Convert the data argument into a Pandas DataFrame if needed. if isinstance(data, Table): # We have an Astropy Table: data, meta, units = self._from_table(data) elif isinstance(data, np.ndarray): # We have a numpy ndarray. We assume the first column is a dt index data = pd.DataFrame(data=data[:, 1:], index=Time(data[:, 0])) # If there are 1 or 2 more arguments: for _ in range(2): if (len(args) > i+1): # If that next argument isn't data but is metaddata or units: if not isinstance(args[i+1], (np.ndarray, Table, pd.DataFrame)): if self._validate_units(args[i+1]): units.update(args[i+1]) i += 1 # an extra increment to account for the units elif self._validate_meta(args[i+1]): # if we have an astropy.io FITS header then convert # to preserve multi-line comments if isinstance(args[i+1], astropy.io.fits.header.Header): args[i+1] = MetaDict(sunpy.io.header.FileHeader(args[i+1])) meta.update(args[i+1]) i += 1 # an extra increment to account for the meta # Add a 3-tuple for this TimeSeries. data_header_unit_tuples.append((data, meta, units)) # Filepath elif (isinstance(arg, str) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) result = self._read_file(path, **kwargs) data_header_pairs, filepaths = _apply_result(data_header_pairs, filepaths, result) # Directory elif (isinstance(arg, str) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: # returns a boolean telling us if it were read and either a # tuple or the original filepath for reading by a source result = self._read_file(afile, **kwargs) data_header_pairs, filepaths = _apply_result(data_header_pairs, filepaths, result) # Glob elif isinstance(arg, str) and '*' in arg: files = glob.glob(os.path.expanduser(arg)) for afile in files: # returns a boolean telling us if it were read and either a # tuple or the original filepath for reading by a source result = self._read_file(afile, **kwargs) data_header_pairs, filepaths = _apply_result(data_header_pairs, filepaths, result) # Already a TimeSeries elif isinstance(arg, GenericTimeSeries): already_timeseries.append(arg) # A URL elif (isinstance(arg, str) and _is_url(arg)): url = arg path = download_file(url, get_and_create_download_dir()) result = self._read_file(path, **kwargs) data_header_pairs, filepaths = _apply_result(data_header_pairs, filepaths, result) else: raise NoMatchError("File not found or invalid input") i += 1 # TODO: # In the end, if there are already TimeSeries it should be put in the # same order as the input, currently they are not. return data_header_unit_tuples, data_header_pairs, already_timeseries, filepaths
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of (data, header, unit) (1) * data, header not in a tuple (1) * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. (1) Note that header/unit are optional and in either order, but data but be the first entry in each group. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_unit_tuples = list() data_header_pairs = list() already_timeseries = list() filepaths = list() # Take source kwarg if defined source = kwargs.get('source', None) # Account for nested lists of items. Simply outputs a single list of # items, nested lists are expanded to element level. args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header pair in a tuple if (isinstance(arg, (np.ndarray, Table, pd.DataFrame))):# and self._validate_meta(args[i+1])): # Assume a Pandas Dataframe is given data = arg units = OrderedDict() meta = MetaDict() # Convert the data argument into a Pandas DataFrame if needed. if isinstance(data, Table): # We have an AstroPy Table: data, meta, units = self._from_table(data) elif isinstance(data, np.ndarray): # We have a numpy ndarray. We assume the first column is a dt index data = pd.DataFrame(data=data[:,1:], index=Time(data[:,0])) # If there are 1 or 2 more arguments: for _ in range(2): if (len(args) > i+1): # If that next argument isn't data but is metaddata or units: if not isinstance(args[i+1], (np.ndarray, Table, pd.DataFrame)): if self._validate_units(args[i+1]): units.update(args[i+1]) i += 1 # an extra increment to account for the units elif self._validate_meta(args[i+1]): # if we have an astropy.io FITS header then convert # to preserve multi-line comments if isinstance(args[i+1], astropy.io.fits.header.Header): args[i+1] = MetaDict(sunpy.io.header.FileHeader(args[i+1])) meta.update(args[i+1]) i += 1 # an extra increment to account for the meta # Add a 3-tuple for this TimeSeries. data_header_unit_tuples.append((data, meta, units)) # Filepath elif (isinstance(arg, six.string_types) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) read, result = self._read_file(path, **kwargs) if read: data_header_pairs.append(result) else: filepaths.append(result) # Directory elif (isinstance(arg, six.string_types) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: # returns a boolean telling us if it were read and either a # tuple or the original filepath for reading by a source read, result = self._read_file(afile, **kwargs) if read: data_header_pairs.append(result) else: filepaths.append(result) # Glob elif (isinstance(arg, six.string_types) and '*' in arg): files = glob.glob(os.path.expanduser(arg)) for afile in files: # data_header_unit_tuples += self._read_file(afile, **kwargs) # returns a boolean telling us if it were read and either a # tuple or the original filepath for reading by a source read, result = self._read_file(afile, **kwargs) if read: data_header_pairs.append(result) else: filepaths.append(result) # Already a TimeSeries elif isinstance(arg, GenericTimeSeries): already_timeseries.append(arg) # A URL elif (isinstance(arg,six.string_types) and _is_url(arg)): default_dir = sunpy.config.get("downloads", "download_dir") url = arg path = download_file(url, default_dir) pairs = self._read_file(path, **kwargs) #data_header_pairs += pairs filepaths.append(pairs[1]) else: #raise ValueError("File not found or invalid input") raise NoMatchError("File not found or invalid input") i += 1 # TODO: # In the end, if there are already TimeSeries it should be put in the # same order as the input, currently they are not. return data_header_unit_tuples, data_header_pairs, already_timeseries, filepaths
def differential_rotate(smap, observer=None, time=None, **diff_rot_kwargs): """ Warp a `~sunpy.map.GenericMap` to take into account both solar differential rotation and the changing location of the observer. .. warning:: This function, while greatly improved in 1.0, is still experimental. Please validate that it gives you results you expect and report any discrepancies on the SunPy issue tracker. The function transforms the input map data pixels by first rotating each pixel according to solar differential rotation. The amount of solar differential applied is calculated by the time difference between the observation time of map and the new observation time, as specified by either the "time" keyword or the "obstime" property of the "observer" keyword. The location of the rotated pixels are then transformed to locations on the Sun as seen from the new observer position. This is desirable since in most cases the observer does not remain at a fixed position in space. If the "time" keyword is used then the new observer position is assumed to be based on the location of the Earth. If the "observer" keyword is used then this defines the new observer position. The function works with full disk maps and maps that contain portions of the solar disk (maps that are entirely off-disk will raise an error). When the input map contains the full disk, the output map has the same dimensions as the input map. When the input map images only part of the solar disk, only the on-disk pixels are differentially rotated and the output map can have a different dimensions compared to the input map. In this case any off-disk emission shown in the input map is not included in the output map. Parameters ---------- smap : `~sunpy.map.GenericMap` Original map that we want to transform. observer : `~astropy.coordinates.BaseCoordinateFrame`, `~astropy.coordinates.SkyCoord`, `None`, optional The location of the new observer. Instruments in Earth orbit can be approximated by using the position of the Earth at the observation time of the new observer. time : sunpy-compatible time, `~astropy.time.TimeDelta`, `~astropy.units.Quantity`, `None`, optional Used to define the duration over which the amount of solar rotation is calculated. If 'time' is an `~astropy.time.Time` then the time interval is difference between 'time' and the map observation time. If 'time' is `~astropy.time.TimeDelta` or `~astropy.units.Quantity` then the calculation is "initial_obstime + time". Returns ------- `~sunpy.map.GenericMap` A map with the result of applying solar differential rotation to the input map. """ # If the entire map is off-disk, return an error so the user is aware. if is_all_off_disk(smap): raise ValueError( "The entire map is off disk. No data to differentially rotate.") # Get the new observer new_observer = _get_new_observer(smap.date, observer, time) # Only this function needs scikit image from skimage import transform # Check whether the input contains the full disk of the Sun is_sub_full_disk = not contains_full_disk(smap) if is_sub_full_disk: # Find the minimal submap of the input map that includes all the # on disk pixels. This is required in order to calculate how # much to pad the output (solar-differentially rotated) data array by # compared to the input map. # The amount of padding is dependent on the amount of solar differential # rotation and where the on-disk pixels are (since these pixels are the only ones # subject to solar differential rotation). if not is_all_on_disk(smap): # Get the bottom left and top right coordinates that are the # vertices that define a box that encloses the on disk pixels bottom_left, top_right = on_disk_bounding_coordinates(smap) # Create a submap that excludes the off disk emission that does # not need to be rotated. smap = smap.submap(bottom_left, top_right=top_right) bottom_left = smap.bottom_left_coord top_right = smap.top_right_coord # Get the edges of the minimal submap that contains all the on-disk pixels. edges = map_edges(smap) # Calculate where the output array moves to. # Rotate the top and bottom edges rotated_top = _rotate_submap_edge(smap, edges[0], observer=new_observer, **diff_rot_kwargs) rotated_bottom = _rotate_submap_edge(smap, edges[1], observer=new_observer, **diff_rot_kwargs) # Rotate the left and right hand edges rotated_lhs = _rotate_submap_edge(smap, edges[2], observer=new_observer, **diff_rot_kwargs) rotated_rhs = _rotate_submap_edge(smap, edges[3], observer=new_observer, **diff_rot_kwargs) # Calculate the bounding box of the rotated map rotated_bl, rotated_tr = _get_bounding_coordinates( [rotated_top, rotated_bottom, rotated_lhs, rotated_rhs]) # Calculate the maximum distance in pixels the map has moved by comparing # how far the original and rotated bounding boxes have moved. diff_x = [(np.abs(rotated_bl.Tx - bottom_left.Tx)).value, (np.abs(rotated_tr.Tx - top_right.Tx)).value] deltax = int(np.ceil(np.max(diff_x) / smap.scale.axis1).value) diff_y = [(np.abs(rotated_bl.Ty - bottom_left.Ty)).value, (np.abs(rotated_tr.Ty - top_right.Ty)).value] deltay = int(np.ceil(np.max(diff_y) / smap.scale.axis2).value) # Create a new `smap` with the padding around it padded_data = np.pad(smap.data, ((deltay, deltay), (deltax, deltax)), 'constant', constant_values=0) padded_meta = deepcopy(smap.meta) padded_meta['naxis2'], padded_meta['naxis1'] = smap.data.shape padded_meta['crpix1'] += deltax padded_meta['crpix2'] += deltay # Create the padded map that will be used to create the rotated map. smap = smap._new_instance(padded_data, padded_meta) # Check for masked maps if smap.mask is not None: smap_data = np.ma.array(smap.data, mask=smap.mask) else: smap_data = smap.data # Create the arguments for the warp function. warp_args = {'smap': smap, 'new_observer': new_observer} warp_args.update(diff_rot_kwargs) # Apply solar differential rotation as a scikit-image warp out_data = transform.warp(smap_data, inverse_map=_warp_sun_coordinates, map_args=warp_args, preserve_range=True, cval=np.nan) # Update the meta information with the new date and time. out_meta = deepcopy(smap.meta) if out_meta.get('date_obs', False): del out_meta['date_obs'] out_meta['date-obs'] = new_observer.obstime.strftime( "%Y-%m-%dT%H:%M:%S.%f") # Need to update the observer location for the output map. # Remove all the possible observer keys all_keys = expand_list( [e[0] for e in smap._supported_observer_coordinates]) for key in all_keys: out_meta.pop(key) # Add a new HGS observer out_meta.update(get_observer_meta(new_observer, out_meta['rsun_ref'] * u.m)) if is_sub_full_disk: # Define a new reference pixel and the value at the reference pixel. # Note that according to the FITS convention the first pixel in the # image is at (1.0, 1.0). center_rotated = solar_rotate_coordinate(smap.center, observer=new_observer, **diff_rot_kwargs) out_meta['crval1'] = center_rotated.Tx.value out_meta['crval2'] = center_rotated.Ty.value out_meta['crpix1'] = 1 + smap.data.shape[1]/2.0 + \ ((center_rotated.Tx - smap.center.Tx)/smap.scale.axis1).value out_meta['crpix2'] = 1 + smap.data.shape[0]/2.0 + \ ((center_rotated.Ty - smap.center.Ty)/smap.scale.axis2).value return smap._new_instance(out_data, out_meta).submap(rotated_bl, top_right=rotated_tr) else: return smap._new_instance(out_data, out_meta)
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_pairs = list() already_maps = list() # Account for nested lists of items args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header pair in a tuple if ((type(arg) in [tuple, list]) and len(arg) == 2 and isinstance(arg[0], np.ndarray) and isinstance(arg[1], dict)): data_header_pairs.append(arg) # Data-header pair not in a tuple elif (isinstance(arg, np.ndarray) and isinstance(args[i + 1], dict)): pair = (args[i], args[i + 1]) data_header_pairs.append(pair) i += 1 # an extra increment to account for the data-header pairing # File name elif (isinstance(arg, basestring) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # Directory elif (isinstance(arg, basestring) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Glob elif (isinstance(arg, basestring) and '*' in arg): files = glob.glob(os.path.expanduser(arg)) for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Already a Map elif isinstance(arg, GenericMap): already_maps.append(arg) # A URL elif (isinstance(arg, basestring) and _is_url(arg)): default_dir = sunpy.config.get("downloads", "download_dir") url = arg path = download_file(url, default_dir) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # A database Entry elif isinstance(arg, DatabaseEntry): data_header_pairs += self._read_file(arg.path, **kwargs) else: raise ValueError("File not found or invalid input") i += 1 #TODO: # In the end, if there are aleady maps it should be put in the same # order as the input, currently they are not. return data_header_pairs, already_maps
def _parse_args(self, *args, **kwargs): """ Parses an args list for data-header pairs. args can contain any mixture of the following entries: * tuples of data,header * data, header not in a tuple * data, wcs object in a tuple * data, wcs object not in a tuple * filename, which will be read * directory, from which all files will be read * glob, from which all files will be read * url, which will be downloaded and read * lists containing any of the above. Example ------- self._parse_args(data, header, (data, header), ['file1', 'file2', 'file3'], 'file4', 'directory1', '*.fits') """ data_header_pairs = list() already_maps = list() # Account for nested lists of items args = expand_list(args) # For each of the arguments, handle each of the cases i = 0 while i < len(args): arg = args[i] # Data-header or data-WCS pair if isinstance(arg, SUPPORTED_ARRAY_TYPES): arg_header = args[i+1] if isinstance(arg_header, WCS): arg_header = args[i+1].to_header() if self._validate_meta(arg_header): pair = (args[i], OrderedDict(arg_header)) data_header_pairs.append(pair) i += 1 # an extra increment to account for the data-header pairing # File name elif (isinstance(arg, str) and os.path.isfile(os.path.expanduser(arg))): path = os.path.expanduser(arg) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # Directory elif (isinstance(arg, str) and os.path.isdir(os.path.expanduser(arg))): path = os.path.expanduser(arg) files = [os.path.join(path, elem) for elem in os.listdir(path)] for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Glob elif (isinstance(arg, str) and '*' in arg): files = glob.glob(os.path.expanduser(arg)) for afile in files: data_header_pairs += self._read_file(afile, **kwargs) # Already a Map elif isinstance(arg, GenericMap): already_maps.append(arg) # A URL elif (isinstance(arg, str) and _is_url(arg)): url = arg path = download_file(url, get_and_create_download_dir()) pairs = self._read_file(path, **kwargs) data_header_pairs += pairs # A database Entry elif isinstance(arg, DatabaseEntry): data_header_pairs += self._read_file(arg.path, **kwargs) else: raise ValueError("File not found or invalid input") i += 1 # TODO: # In the end, if there are already maps it should be put in the same # order as the input, currently they are not. return data_header_pairs, already_maps