def verifyUniqueWcsname(fname, wcsname, include_primary=True): """ Report whether or not the specified WCSNAME already exists in the file """ numsci, extname = count_sci_extensions(fname) wnames = altwcs.wcsnames(fname, ext=(extname, 1), include_primary=include_primary) return wcsname.upper() not in [v.upper() for v in wnames.values()]
def verifyUniqueWcsname(fname, wcsname): """ Report whether or not the specified WCSNAME already exists in the file """ uniq = True numsci, extname = count_sci_extensions(fname) wnames = altwcs.wcsnames(fname, ext=(extname, 1)) if wcsname in wnames.values(): uniq = False return uniq
def verifyUniqueWcsname(fname,wcsname): """ Report whether or not the specified WCSNAME already exists in the file """ uniq = True numsci,extname = count_sci_extensions(fname) wnames = altwcs.wcsnames(fname,ext=(extname,1)) if wcsname in wnames.values(): uniq = False return uniq
def create_unique_wcsname(fimg, extnum, wcsname): """ This function evaluates whether the specified wcsname value has already been used in this image. If so, it automatically modifies the name with a simple version ID using wcsname_NNN format. Parameters ---------- fimg : obj PyFITS object of image with WCS information to be updated extnum : int Index of extension with WCS information to be updated wcsname : str Value of WCSNAME specified by user for labelling the new WCS Returns ------- uniqname : str Unique WCSNAME value """ wnames = list(altwcs.wcsnames(fimg, ext=extnum).values()) if wcsname not in wnames: uniqname = wcsname else: # setup pattern to match rpatt = re.compile(wcsname + '_\d') index = 0 for wname in wnames: rmatch = rpatt.match(wname) if rmatch: # get index n = int(wname[wname.rfind('_') + 1:]) if n > index: index = 1 index += 1 # for use with new name uniqname = "%s_%d" % (wcsname, index) return uniqname
def _wcs_key_name(wcs_key, wcs_name, fi, ext, default_key, param_name): wnames = altwcs.wcsnames(fi.image.hdu, ext=ext) if wcs_key is None: if wcs_name is None: wcs_key = sorted(wnames)[default_key] wcs_name = wnames[wcs_key] # report our guess: print(f"Using WCS with WCSNAME '{wcs_name}' (WCS key '{wcs_key}') " f"for '{param_name}'") else: # find associated wcs_key wcs_name_u = wcs_name.upper() for k, name in wnames.items(): if name.upper() == wcs_name_u: wcs_key = k break else: fi.release_all_images() raise KeyError(f"WCS with wcsname '{wcs_name}' not found.") else: wcs_name = wnames[wcs_key] return wcs_key, wcs_name
def update_wcscorr(dest, source=None, extname='SCI', wcs_id=None, active=True): """ Update WCSCORR table with a new row or rows for this extension header. It copies the current set of WCS keywords as a new row of the table based on keyed WCSs as per Paper I Multiple WCS standard). Parameters ---------- dest : HDUList The HDU list whose WCSCORR table should be appended to (the WCSCORR HDU must already exist) source : HDUList, optional The HDU list containing the extension from which to extract the WCS keywords to add to the WCSCORR table. If None, the dest is also used as the source. extname : str, optional The extension name from which to take new WCS keywords. If there are multiple extensions with that name, rows are added for each extension version. wcs_id : str, optional The name of the WCS to add, as in the WCSNAMEa keyword. If unspecified, all the WCSs in the specified extensions are added. active: bool, optional When True, indicates that the update should reflect an update of the active WCS information, not just appending the WCS to the file as a headerlet """ if not isinstance(dest, fits.HDUList): dest = fits.open(dest,mode='update') fname = dest.filename() if source is None: source = dest if extname == 'PRIMARY': return numext = fileutil.countExtn(source, extname) if numext == 0: raise ValueError('No %s extensions found in the source HDU list.' % extname) # Initialize the WCSCORR table extension in dest if not already present init_wcscorr(dest) try: dest.index_of('WCSCORR') except KeyError: return # check to see whether or not this is an up-to-date table # replace with newly initialized table with current format old_table = dest['WCSCORR'] wcscorr_cols = ['WCS_ID','EXTVER', 'SIPNAME', 'HDRNAME', 'NPOLNAME', 'D2IMNAME'] for colname in wcscorr_cols: if colname not in old_table.data.columns.names: print("WARNING: Replacing outdated WCSCORR table...") outdated_table = old_table.copy() del dest['WCSCORR'] init_wcscorr(dest) old_table = dest['WCSCORR'] break # Current implementation assumes the same WCS keywords are in each # extension version; if this should not be assumed then this can be # modified... wcs_keys = altwcs.wcskeys(source[(extname, 1)].header) wcs_keys = [kk for kk in wcs_keys if kk] if ' ' not in wcs_keys: wcs_keys.append(' ') # Insure that primary WCS gets used # apply logic for only updating WCSCORR table with specified keywords # corresponding to the WCS with WCSNAME=wcs_id if wcs_id is not None: wnames = altwcs.wcsnames(source[(extname, 1)].header) wkeys = [] for letter in wnames: if wnames[letter] == wcs_id: wkeys.append(letter) if len(wkeys) > 1 and ' ' in wkeys: wkeys.remove(' ') wcs_keys = wkeys wcshdr = stwcs.wcsutil.HSTWCS(source, ext=(extname, 1)).wcs2header() wcs_keywords = list(wcshdr.keys()) if 'O' in wcs_keys: wcs_keys.remove('O') # 'O' is reserved for original OPUS WCS # create new table for hdr and populate it with the newly updated values new_table = create_wcscorr(descrip=True,numrows=0, padding=len(wcs_keys)*numext) prihdr = source[0].header # Get headerlet related keywords here sipname, idctab = utils.build_sipname(source, fname, "None") npolname, npolfile = utils.build_npolname(source, None) d2imname, d2imfile = utils.build_d2imname(source, None) if 'hdrname' in prihdr: hdrname = prihdr['hdrname'] else: hdrname = '' idx = -1 for wcs_key in wcs_keys: for extver in range(1, numext + 1): extn = (extname, extver) if 'SIPWCS' in extname and not active: tab_extver = 0 # Since it has not been added to the SCI header yet else: tab_extver = extver hdr = source[extn].header if 'WCSNAME'+wcs_key in hdr: wcsname = hdr['WCSNAME' + wcs_key] else: wcsname = utils.build_default_wcsname(hdr['idctab']) selection = {'WCS_ID': wcsname, 'EXTVER': tab_extver, 'SIPNAME':sipname, 'HDRNAME': hdrname, 'NPOLNAME': npolname, 'D2IMNAME':d2imname } # Ensure that an entry for this WCS is not already in the dest # table; if so just skip it rowind = find_wcscorr_row(old_table.data, selection) if np.any(rowind): continue idx += 1 wcs = stwcs.wcsutil.HSTWCS(source, ext=extn, wcskey=wcs_key) wcshdr = wcs.wcs2header() # Update selection column values for key, val in selection.items(): if key in new_table.data.names: new_table.data.field(key)[idx] = val for key in wcs_keywords: if key in new_table.data.names: new_table.data.field(key)[idx] = wcshdr[key + wcs_key] for key in DEFAULT_PRI_KEYS: if key in new_table.data.names and key in prihdr: new_table.data.field(key)[idx] = prihdr[key] # Now look for additional, non-WCS-keyword table column data for key in COL_FITSKW_DICT: fitkw = COL_FITSKW_DICT[key] # Interpret any 'pri.hdrname' or # 'sci.crpix1' formatted keyword names if '.' in fitkw: srchdr,fitkw = fitkw.split('.') if 'pri' in srchdr.lower(): srchdr = prihdr else: srchdr = source[extn].header else: srchdr = source[extn].header if fitkw+wcs_key in srchdr: new_table.data.field(key)[idx] = srchdr[fitkw+wcs_key] # If idx was never incremented, no rows were added, so there's nothing else # to do... if idx < 0: return # Now, we need to merge this into the existing table rowind = find_wcscorr_row(old_table.data, {'wcs_id':['','0.0']}) old_nrows = np.where(rowind)[0][0] new_nrows = new_table.data.shape[0] # check to see if there is room for the new row if (old_nrows + new_nrows) > old_table.data.shape[0]-1: pad_rows = 2 * new_nrows # if not, create a new table with 'pad_rows' new empty rows upd_table = fits.new_table(old_table.columns,header=old_table.header, nrows=old_table.data.shape[0]+pad_rows) else: upd_table = old_table pad_rows = 0 # Now, add for name in old_table.columns.names: if name in new_table.data.names: # reset the default values to ones specific to the row definitions for i in range(pad_rows): upd_table.data.field(name)[old_nrows+i] = old_table.data.field(name)[-1] # Now populate with values from new table upd_table.data.field(name)[old_nrows:old_nrows + new_nrows] = \ new_table.data.field(name) upd_table.header['TROWS'] = old_nrows + new_nrows # replace old extension with newly updated table extension dest['WCSCORR'] = upd_table
def update_wcscorr(dest, source=None, extname='SCI', wcs_id=None, active=True): """ Update WCSCORR table with a new row or rows for this extension header. It copies the current set of WCS keywords as a new row of the table based on keyed WCSs as per Paper I Multiple WCS standard). Parameters ---------- dest : HDUList The HDU list whose WCSCORR table should be appended to (the WCSCORR HDU must already exist) source : HDUList, optional The HDU list containing the extension from which to extract the WCS keywords to add to the WCSCORR table. If None, the dest is also used as the source. extname : str, optional The extension name from which to take new WCS keywords. If there are multiple extensions with that name, rows are added for each extension version. wcs_id : str, optional The name of the WCS to add, as in the WCSNAMEa keyword. If unspecified, all the WCSs in the specified extensions are added. active: bool, optional When True, indicates that the update should reflect an update of the active WCS information, not just appending the WCS to the file as a headerlet """ if not isinstance(dest, fits.HDUList): dest = fits.open(dest, mode='update') fname = dest.filename() if source is None: source = dest if extname == 'PRIMARY': return numext = fileutil.countExtn(source, extname) if numext == 0: raise ValueError('No %s extensions found in the source HDU list.' % extname) # Initialize the WCSCORR table extension in dest if not already present init_wcscorr(dest) try: dest.index_of('WCSCORR') except KeyError: return # check to see whether or not this is an up-to-date table # replace with newly initialized table with current format old_table = dest['WCSCORR'] wcscorr_cols = [ 'WCS_ID', 'EXTVER', 'SIPNAME', 'HDRNAME', 'NPOLNAME', 'D2IMNAME' ] for colname in wcscorr_cols: if colname not in old_table.data.columns.names: print("WARNING: Replacing outdated WCSCORR table...") outdated_table = old_table.copy() del dest['WCSCORR'] init_wcscorr(dest) old_table = dest['WCSCORR'] break # Current implementation assumes the same WCS keywords are in each # extension version; if this should not be assumed then this can be # modified... wcs_keys = altwcs.wcskeys(source[(extname, 1)].header) wcs_keys = [kk for kk in wcs_keys if kk] if ' ' not in wcs_keys: wcs_keys.append(' ') # Insure that primary WCS gets used # apply logic for only updating WCSCORR table with specified keywords # corresponding to the WCS with WCSNAME=wcs_id if wcs_id is not None: wnames = altwcs.wcsnames(source[(extname, 1)].header) wkeys = [] for letter in wnames: if wnames[letter] == wcs_id: wkeys.append(letter) if len(wkeys) > 1 and ' ' in wkeys: wkeys.remove(' ') wcs_keys = wkeys wcshdr = stwcs.wcsutil.HSTWCS(source, ext=(extname, 1)).wcs2header() wcs_keywords = list(wcshdr.keys()) if 'O' in wcs_keys: wcs_keys.remove('O') # 'O' is reserved for original OPUS WCS # create new table for hdr and populate it with the newly updated values new_table = create_wcscorr(descrip=True, numrows=0, padding=len(wcs_keys) * numext) prihdr = source[0].header # Get headerlet related keywords here sipname, idctab = utils.build_sipname(source, fname, "None") npolname, npolfile = utils.build_npolname(source, None) d2imname, d2imfile = utils.build_d2imname(source, None) if 'hdrname' in prihdr: hdrname = prihdr['hdrname'] else: hdrname = '' idx = -1 for wcs_key in wcs_keys: for extver in range(1, numext + 1): extn = (extname, extver) if 'SIPWCS' in extname and not active: tab_extver = 0 # Since it has not been added to the SCI header yet else: tab_extver = extver hdr = source[extn].header if 'WCSNAME' + wcs_key in hdr: wcsname = hdr['WCSNAME' + wcs_key] else: wcsname = utils.build_default_wcsname(hdr['idctab']) selection = { 'WCS_ID': wcsname, 'EXTVER': tab_extver, 'SIPNAME': sipname, 'HDRNAME': hdrname, 'NPOLNAME': npolname, 'D2IMNAME': d2imname } # Ensure that an entry for this WCS is not already in the dest # table; if so just skip it rowind = find_wcscorr_row(old_table.data, selection) if np.any(rowind): continue idx += 1 wcs = stwcs.wcsutil.HSTWCS(source, ext=extn, wcskey=wcs_key) wcshdr = wcs.wcs2header() # Update selection column values for key, val in selection.items(): if key in new_table.data.names: new_table.data.field(key)[idx] = val for key in wcs_keywords: if key in new_table.data.names: new_table.data.field(key)[idx] = wcshdr[key + wcs_key] for key in DEFAULT_PRI_KEYS: if key in new_table.data.names and key in prihdr: new_table.data.field(key)[idx] = prihdr[key] # Now look for additional, non-WCS-keyword table column data for key in COL_FITSKW_DICT: fitkw = COL_FITSKW_DICT[key] # Interpret any 'pri.hdrname' or # 'sci.crpix1' formatted keyword names if '.' in fitkw: srchdr, fitkw = fitkw.split('.') if 'pri' in srchdr.lower(): srchdr = prihdr else: srchdr = source[extn].header else: srchdr = source[extn].header if fitkw + wcs_key in srchdr: new_table.data.field(key)[idx] = srchdr[fitkw + wcs_key] # If idx was never incremented, no rows were added, so there's nothing else # to do... if idx < 0: return # Now, we need to merge this into the existing table rowind = find_wcscorr_row(old_table.data, {'wcs_id': ['', '0.0']}) old_nrows = np.where(rowind)[0][0] new_nrows = new_table.data.shape[0] # check to see if there is room for the new row if (old_nrows + new_nrows) > old_table.data.shape[0] - 1: pad_rows = 2 * new_nrows # if not, create a new table with 'pad_rows' new empty rows upd_table = fits.new_table(old_table.columns, header=old_table.header, nrows=old_table.data.shape[0] + pad_rows) else: upd_table = old_table pad_rows = 0 # Now, add for name in old_table.columns.names: if name in new_table.data.names: # reset the default values to ones specific to the row definitions for i in range(pad_rows): upd_table.data.field(name)[old_nrows + i] = old_table.data.field(name)[-1] # Now populate with values from new table upd_table.data.field(name)[old_nrows:old_nrows + new_nrows] = \ new_table.data.field(name) upd_table.header['TROWS'] = old_nrows + new_nrows # replace old extension with newly updated table extension dest['WCSCORR'] = upd_table
def apply_tweak(drz_file, orig_wcs_name, output_wcs_name=None, input_files=None, default_extname='SCI', **kwargs): """ Apply WCS solution recorded in drizzled file to distorted input images (``_flt.fits`` files) used to create the drizzled file. It is assumed that if input images given by ``input_files`` are drizzled together, they would produce the drizzled image given by ``drz_file`` image and with the "original" primary WCS. It is also assumed that drizzled image was aligned using ``tweakreg`` either to another image or to an external reference catalog. We will refer to the primary WCS in the drizzled image _before_ ``tweakreg`` was run as the "original" WCS and the WCS _after_ ``tweakreg`` was run as "tweaked" WCS. By comparing both "original" and "tweaked" WCS, ``apply_wcs`` computes the correction that was applied by ``tweakreg`` to the "original" WCS and converts this correction in the drizzled image frame into a correction in the input image's (``input_files``) frame that will be applied to the primary WCS of input images. If updated input images are now resampled again, they would produce an image very close to ``drz_file`` but with a primary WCS very similar to the "tweaked" WCS instead of the "original" WCS. Parameters ---------- drz_file : str File name of the drizzled image that contains both the "original" and "tweaked" WCS. Even though wildcards are allowed in the file name, their expansion must resolve to a single image file. By default, ``apply_tweak`` looks for the first image-like HDU in the drizzled image. To specify a particular extension from which to load WCS, append extension specification after the file name, for example: - ``'image_drz.fits[sci,1]'`` for first "sci" extension - ``'image_drz.fits[1]'`` for the first extension - ``'image_drz.fits[0]'`` for the primary HDU orig_wcs_name : str Name (provided by the ``WCSNAME?`` header keyword where ``?`` respesents a letter A-Z) of the "original" WCS. This is the WCS of the resampled image (obtained by drizzling all input images) _before_ this resampled image was aligned ("tweaked") to another image/catalog. If ``orig_wcs_name`` is `None`, the the original WCS _must be specified_ using ``orig_wcs_key``. When ``orig_wcs_key`` is provided, ``orig_wcs_name`` is ignored altogether. output_wcs_name : str, None Value of ``WCSNAME`` to be used to label the updated solution in the input (e.g., ``_flt.fits``) files. If left blank or ``None``, it will default to using either the current (primary) ``WCSNAME`` value from the ``drz_file`` or from the alternate WCS given by the ``tweaked_wcs_name`` or ``tweaked_wcs_key`` parameters. input_files : str, None Filenames of distorted images whose primary WCS is to be updated with the same transformation as used in the "tweaked" drizzled image. Default value of `None` indicates that input image filenames will be derived from the ``D*DATA`` keywords written out by the ``AstroDrizzle``. If they can not be found, the task will quit. ``input_files`` string can contain one of the following: * a comma-separated list of valid science image file names (see note below) and (optionally) extension specifications, e.g.: ``'j1234567q_flt.fits[1], j1234568q_flt.fits[sci,2]'``; * an @-file name, e.g., ``'@files_to_match.txt'``. .. note:: **Valid** **science** **image** **file** **names** are: * file names of existing FITS, GEIS, or WAIVER FITS files; * partial file names containing wildcard characters, e.g., ``'*_flt.fits'``; * Association (ASN) tables (must have ``_asn``, or ``_asc`` suffix), e.g., ``'j12345670_asn.fits'``. .. warning:: @-file names **MAY** **NOT** be followed by an extension specification. .. warning:: If an association table or a partial file name with wildcard characters is followed by an extension specification, it will be considered that this extension specification applies to **each** file name in the association table or **each** file name obtained after wildcard expansion of the partial file name. default_extname : str Extension name of extensions in input images whose primary WCS should be updated. This value is used only when file names provided in ``input_files`` do not contain extension specifications. Other Parameters ---------------- tweaked_wcs_name : str Name of the "tweaked" WCS. This is the WCS of the resampled image (obtained by drizzling all input images) _after_ this resampled image was aligned ("tweaked") to another image/catalog. When neither ``tweaked_wcs_name`` nor ````tweaked_wcs_key`` are not provided, ``apply_tweak`` will take the current primary WCS in the drizzled image as a "tweaked" WCS. ``tweaked_wcs_name`` is ignored when ``tweaked_wcs_key`` is provided. tweaked_wcs_key : {' ', 'A'-'Z'} Same as ``tweaked_wcs_name`` except it specifies a WCS by key instead of name. When provided, ``tweaked_wcs_name`` is ignored. orig_wcs_key : {' ', 'A'-'Z'} Same as ``orig_wcs_name`` except it specifies a WCS by key instead of name. When provided, ``orig_wcs_name`` is ignored. Notes ----- The algorithm used by this function is based on linearization of the exact compound operator that converts input image coordinates to the coordinates (in the input image) that would result in alignment with the new drizzled image WCS. .. warning:: Parameters ``orig_wcs_name`` and ``tweaked_wcs_name`` (or their "key" equivalents) allow computation of transformation between *any two WCS* in the drizzled image and application of this transformation to the primary WCS of the input images. This will produce an expected result **only if** the WCS pointed to by ``orig_wcs_name`` was obtained by drizzling input images with their current primary WCS. EXAMPLES -------- A drizzled image named ``acswfc_mos2_drz.fits`` was created from 4 images using ``AstroDrizzle``. The primary WCS of this drizzled image was named ``'INITIAL_GUESS'``. This drizzled image was then aligned to some other image using ``TweakReg`` and the updated ("tweaked") primary WCS was named ``'BEST_WCS'`` while the previous primary WCS - the WCS named ``'INITIAL_GUESS'`` - was archived by ``TweakReg`` under WCS key ``'C'``. We will refer to this archived WCS as the "original" WCS. ``apply_tweak`` can now be used to compute the transformation between the original and the tweaked WCS and apply this transformation to the WCS of each of the input images that were drizzle-combined to produce the resampled image ``acswfc_mos2_drz.fits``. The simplest way to accomplish this would be to run ``apply_tweak()`` using default parameters: >>> from drizzlepac import tweakback >>> tweakback.apply_tweak('acswfc_mos2_drz.fits', orig_wcs_name='INITIAL_GUESS') or >>> tweakback.apply_tweak('acswfc_mos2_drz.fits', orig_wcs_key='C') If the same WCS should be applied to a specific set of images or extensions in those images, then we can explicitly specify input files: >>> tweakback.apply_tweak( ... 'acswfc_mos2_drz.fits', ... input='img_mos2a_flt.fits,img_mos2c_flt.fits[1],img_mos2d_flt.fits[sci,1]' ... ) In the examples above, current primary WCS of the input ``'img_mos2?_flt.fits'`` files will be archived and the primary WCS will be replaced with a "tweaked" WCS obtained by applying relevant transformations to the current primary WCS. Because we did not specify ``output_wcs_name``, the name of this tweaked primary WCS in the input images will be set to ``'BEST_WCS'``. See Also -------- stwcs.wcsutil.altwcs: Alternate WCS implementation """ print(f"\n*** 'apply_tweak' version {__version__:s} started " f"at {util._ptime()[0]:s}: ***\n") tweaked_wcs_name = kwargs.get('tweaked_wcs_name', None) tweaked_wcs_key = kwargs.get('tweaked_wcs_key', None) orig_wcs_key = kwargs.get('orig_wcs_key', None) tweaked_wcs_key = _process_wcs_key_par('tweaked_wcs_key', kwargs) orig_wcs_key = _process_wcs_key_par('orig_wcs_key', kwargs) # load drizzled image and extract input file names (if needed) and # load specified WCS: fis = parse_cs_line(drz_file, default_ext='*', fnamesOnly=False, doNotOpenDQ=True, im_fmode="readonly") if len(fis) == 0: raise FileNotFoundError(f"Drizzled file '{drz_file}' not found.") elif len(fis) > 1: for f in fis: f.release_all_images() raise ValueError("When expanded, 'drz_file' should correspond to a " "single file.") fi = fis[0] hdul = fi.image.hdu if len(fi.fext) == 1: drz_sciext = fi.fext[0] elif fi.fext: fi.release_all_images() raise ValueError( "Input drizzled image contains multiple image-like extensions. " "Please explicitly specify a single extension containing desired " "WCS.") else: fi.release_all_images() raise ValueError( "Specified extension was not found in the input drizzled image.") # check that there are at least two WCS in the drizzled image header: wkeys = altwcs.wcskeys(hdul, ext=drz_sciext) if len(wkeys) < 2: fi.release_all_images() raise ValueError(f"'{fi.image}[{ext2str(drz_sciext)}]' must " "contain at least two valid WCS: original and " "updated by tweakreg.") # load "tweaked" WCS tweaked_wcs_key, tweaked_wcs_name = _wcs_key_name( tweaked_wcs_key, tweaked_wcs_name, fi=fi, ext=drz_sciext, default_key=0, param_name='tweaked_wcs_name') tweaked_wcs = wcsutil.HSTWCS(hdul, ext=drz_sciext, wcskey=tweaked_wcs_key) # load "original" WCS if orig_wcs_key is None and orig_wcs_name is None: fi.release_all_images() raise ValueError( "Either 'orig_wcs_name' or 'orig_wcs_key' must be specified.") # default_key=-1 below is useless since we require that either # orig_wcs_key or orig_wcs_name be specified. However, in the future, # if we allow both to be None, we can use the last WCS key as the default # for the "original" WCS (last WCS key in the list). orig_wcs_key, orig_wcs_name = _wcs_key_name(orig_wcs_key, orig_wcs_name, fi=fi, ext=drz_sciext, default_key=-1, param_name='orig_wcs_name') orig_wcs = wcsutil.HSTWCS(hdul, ext=drz_sciext, wcskey=orig_wcs_key) # get RMS values reported for new solution crderr1 = fi.image.hdu[drz_sciext].header.get('CRDER1' + orig_wcs_key, 0.0) crderr2 = fi.image.hdu[drz_sciext].header.get('CRDER2' + orig_wcs_key, 0.0) fi.release_all_images() # done with the resampled image # Process the list of input files: if not isinstance(default_extname, str): raise TypeError("Argument 'default_extname' must be a string") default_extname = default_extname.strip() if default_extname.upper() == 'PRIMARY': ext2get = ('PRIMARY', 1) else: ext2get = (default_extname, '*') if input_files is None: # get input (FLT) file names from the drizzled image. This information # is recorded in the primary header of the drizzled image. input_files = ",".join(hdul[0].header["D???DATA"].values()) # Build a list of input files and extensions fnames_ext = {} fis = parse_cs_line(input_files, default_ext=ext2get, fnamesOnly=False, doNotOpenDQ=True, im_fmode="readonly") for f in fis: f.release_all_images() if f.image in fnames_ext: fnames_ext[f.image] |= set(f.fext) else: fnames_ext[f.image] = set(f.fext) if output_wcs_name is None: output_wcs_name = tweaked_wcs_name print(f"\n* Setting 'output_wcs_name' to '{output_wcs_name}'") auto_output_name = True else: auto_output_name = False output_wcs_name_u = output_wcs_name.strip().upper() # Compute tweakback transformation to each extension of each input file. # This is the main part of this function. # Before applying new WCS solution, make sure we can use the same # output WCS name for the updated WCS in all input images. # Also, this gives us opportunity to remove duplicate extensions, if any. final_wcs_info = [] for fname, extlist in fnames_ext.items(): print(f"\n* Working on input image {fname:s} ...") fis = parse_cs_line(f"{fname}", default_ext=ext2get, fnamesOnly=False, doNotOpenDQ=True, im_fmode="readonly") if len(fis) != 1: fi.release_all_images() raise AssertionError( "The algorithm should not open more than one file.") fi = fis[0] if not fi.fext: fi.release_all_images() print( f" No valid input image extension found. Skipping image {fname}.\n" ) continue current_wcs_info = { 'fname': fname, 'extlist': [], 'archived_wcs_name': [], 'updated_primary_wcs': [] } final_wcs_info.append(current_wcs_info) # Process extensions hdu_list = [] # to avoid processing duplicate hdus try: for ext in extlist: imhdulist = fi.image.hdu hdu = imhdulist[ext] if hdu in hdu_list: continue hdu_list.append(hdu) current_wcs_info['extlist'].append(ext) # Find the name under which to archive current WCS: all_wcs_names = [ v.upper() for v in altwcs.wcsnames( imhdulist, ext, include_primary=False).values() ] if output_wcs_name_u in all_wcs_names: if auto_output_name: raise ValueError( "Current value of 'output_wcs_name' was set to " f"'{tweaked_wcs_name}' by default. However, this " f"WCS name value was already used in {fname:s}[{ext2str(ext)}]. " "Please re-run 'apply_tweak' again and explicitly " "provide a unique value for the output WCS name.") else: raise ValueError( "Provided value of 'output_wcs_name' - '{tweaked_wcs_name}' - " f"was already used in {fname:s}[{ext2str(ext)}]. " "Please re-run 'apply_tweak' again and explicitly " "provide a unique value for the output WCS name.") if 'WCSNAME' in imhdulist[ext].header: pri_wcs_name = imhdulist[ext].header['WCSNAME'].strip() else: pri_wcs_name = 'NONAME' # add current output WCS name to the list so that archived # primary WCS will be archived under a different name: all_wcs_names.append(output_wcs_name) archived_name = altwcs._auto_increment_wcsname( pri_wcs_name, all_wcs_names) current_wcs_info['archived_wcs_name'].append(archived_name) # compute updated WCS: new_wcs = wcsutil.HSTWCS(imhdulist, ext=ext) update_chip_wcs(new_wcs, orig_wcs, tweaked_wcs, xrms=crderr1, yrms=crderr2) new_wcs.setOrient() current_wcs_info['updated_primary_wcs'].append(new_wcs) print( f" - Computed new WCS solution for {fname:s}[{ext2str(ext)}]:" ) repr_wcs = repr(new_wcs) print('\n'.join( [' ' + l.strip() for l in repr_wcs.split('\n')])) finally: fi.release_all_images() print("\n* Saving updated WCS to image headers:") for fwi in final_wcs_info: if not fwi['extlist']: continue fname = fwi['fname'] fis = parse_cs_line(f"{fname}", default_ext=ext2get, fnamesOnly=False, doNotOpenDQ=True, im_fmode="update") fi = fis[0] # Process extensions try: for ext, archived_name, new_wcs in zip(fwi['extlist'], fwi['archived_wcs_name'], fwi['updated_primary_wcs']): imhdulist = fi.image.hdu hdu = imhdulist[ext] hdu.header['HISTORY'] = ( f"apply_tweak version: {__version__} ({date.today().isoformat():s})" ) # Archive current primary WCS: awcs_key, awcs_name = altwcs.archive_wcs( imhdulist, ext, wcsname=archived_name, mode=altwcs.ArchiveMode.NO_CONFLICT) hdu.header['HISTORY'] = ( "apply_tweak: Archived Primary WCS under key " f"'{awcs_key}' on {date.today().isoformat():s}") hdu.header['HISTORY'] = ( f"apply_tweak: WCSNAME{awcs_key}='{awcs_name}'") # Update primary WCS of this extension: wcs_hdr = new_wcs.wcs2header(idc2hdr=new_wcs.idcscale is not None, relax=True) wcs_hdr.set('WCSNAME', output_wcs_name, before=0) wcs_hdr.set('WCSTYPE', updatehdr.interpret_wcsname_type(output_wcs_name), after=0) wcs_hdr.set('ORIENTAT', new_wcs.orientat, after=len(wcs_hdr)) hdu.header.update(wcs_hdr) hdu.header['HISTORY'] = ( f"apply_tweak: Applied Primary WCS correction on {date.today().isoformat():s}" ) str_extlist = '; '.join(map(ext2str, fwi['extlist'])) print(f" - Updated '{fname:s}', extensions: {str_extlist}") finally: util.updateNEXTENDKw(imhdulist) fi.release_all_images()