Basic implemeentation of the astrometry.net astrometrical fitter. More...

Inheritance diagram for lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask:

Public Member Functions
def	__init__ (self, config, andConfig=None, kwargs)
	Construct an ANetBasicAstrometryTask. More...

def	memusage (self, prefix='')

def	useKnownWcs (self, sourceCat, wcs=None, exposure=None, filterName=None, bbox=None, calculateSip=None)
	Return an InitialAstrometry object, just like determineWcs, but assuming the given input WCS is correct. More...

def	determineWcs (self, sourceCat, exposure, kwargs)

def	determineWcs2 (self, sourceCat, kwargs)

def	getBlindWcsSolution (self, sourceCat, exposure=None, wcs=None, bbox=None, radecCenter=None, searchRadius=None, pixelScale=None, filterName=None, doTrim=False, usePixelScale=True, useRaDecCenter=True, useParity=True, searchRadiusScale=2.)

def	getSipWcsFromWcs (self, wcs, bbox, ngrid=20, linearizeAtCenter=True)
	Get a TAN-SIP WCS, starting from an existing WCS. More...

def	getSipWcsFromCorrespondences (self, origWcs, refCat, sourceCat, bbox)

def	plotSolution (self, matches, wcs, imageSize)

def	getColumnName (self, filterName, columnMap, default=None)

Public Attributes
	config

	refObjLoader

Static Public Attributes
	ConfigClass = ANetBasicAstrometryConfig

Detailed Description

Basic implemeentation of the astrometry.net astrometrical fitter.

A higher-level class ANetAstrometryTask takes care of dealing with the fact that the initial WCS is probably only a pure TAN SIP, yet we may have significant distortion and a good estimate for that distortion.

About Astrometry.net index files (astrometry_net_data):

There are three components of an index file: a list of stars (stored as a star kd-tree), a list of quadrangles of stars ("quad file") and a list of the shapes ("codes") of those quadrangles, stored as a code kd-tree.

Each index covers a region of the sky, defined by healpix nside and number, and a range of angular scales. In LSST, we share the list of stars in a part of the sky between multiple indexes. That is, the star kd-tree is shared between multiple indices (quads and code kd-trees). In the astrometry.net code, this is called a "multiindex".

It is possible to "unload" and "reload" multiindex (and index) objects. When "unloaded", they consume no FILE or mmap resources.

The multiindex object holds the star kd-tree and gives each index object it holds a pointer to it, so it is necessary to multiindex_reload_starkd() before reloading the indices it holds. The multiindex_unload() method, on the other hand, unloads its starkd and unloads each index it holds.

Definition at line 216 of file anetBasicAstrometry.py.

Constructor & Destructor Documentation

◆ init()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.__init__	(	self,
		config,
		andConfig = `None`,
		kwargs
	)

Construct an ANetBasicAstrometryTask.

Parameters

[in]	config	configuration (an instance of self.ConfigClass)
[in]	andConfig	astrometry.net data config (an instance of AstromNetDataConfig, or None); if None then use andConfig.py in the astrometry_net_data product (which must be setup)
[in]	kwargs	additional keyword arguments for pipe_base Task.__init__

Exceptions

RuntimeError if andConfig is None and the configuration cannot be found, either because astrometry_net_data is not setup in eups or because the setup version does not include the file "andConfig.py"

Definition at line 253 of file anetBasicAstrometry.py.

                  **kwargs):
         r"""!Construct an ANetBasicAstrometryTask
 
         @param[in] config  configuration (an instance of self.ConfigClass)
         @param[in] andConfig  astrometry.net data config (an instance of AstromNetDataConfig, or None);
             if None then use andConfig.py in the astrometry_net_data product (which must be setup)
         @param[in] kwargs  additional keyword arguments for pipe_base Task.\_\_init\_\_
 
         @throw RuntimeError if andConfig is None and the configuration cannot be found,
             either because astrometry_net_data is not setup in eups
             or because the setup version does not include the file "andConfig.py"
         """
         pipeBase.Task.__init__(self, config=config, **kwargs)
         self.config = config
         # this is not a subtask because it cannot safely be retargeted
         self.refObjLoader = LoadAstrometryNetObjectsTask(
             config=self.config,
             andConfig=andConfig,
             log=self.log,
             name="loadAN",
         )
         self.refObjLoader._readIndexFiles()
 

Member Function Documentation

◆ determineWcs()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.determineWcs	(	self,
		sourceCat,
		exposure,
		kwargs
	)

Find a WCS solution for the given 'sourceCat' in the given
'exposure', getting other parameters from config.

Valid kwargs include:

'radecCenter', an afw.geom.SpherePoint giving the ICRS RA,Dec position
   of the center of the field.  This is used to limit the
   search done by Astrometry.net (to make it faster and load
   fewer index files, thereby using less memory).  Defaults to
   the RA,Dec center from the exposure's WCS; turn that off
   with the boolean kwarg 'useRaDecCenter' or config option
   'useWcsRaDecCenter'

'useRaDecCenter', a boolean.  Don't use the RA,Dec center from
   the exposure's initial WCS.

'searchRadius', in degrees, to search for a solution around
   the given 'radecCenter'; default from config option
   'raDecSearchRadius'.

'useParity': parity is the 'flip' of the image.  Knowing it
   reduces the search space (hence time) for Astrometry.net.
   The parity can be computed from the exposure's WCS (the
   sign of the determinant of the CD matrix); this option
   controls whether we do that or force Astrometry.net to
   search both parities.  Default from config.useWcsParity.

'pixelScale': geom.Angle, estimate of the angle-per-pixel
   (ie, arcseconds per pixel).  Defaults to a value derived
   from the exposure's WCS.  If enabled, this value, plus or
   minus config.pixelScaleUncertainty, will be used to limit
   Astrometry.net's search.

'usePixelScale': boolean.  Use the pixel scale to limit
   Astrometry.net's search?  Defaults to config.useWcsPixelScale.

'filterName', a string, the filter name of this image.  Will
   be mapped through the 'filterMap' config dictionary to a
   column name in the astrometry_net_data index FITS files.
   Defaults to the exposure.getFilter() value.

'bbox', bounding box of exposure; defaults to exposure.getBBox()

Definition at line 403 of file anetBasicAstrometry.py.

     def determineWcs(self, sourceCat, exposure, **kwargs):
         """Find a WCS solution for the given 'sourceCat' in the given
         'exposure', getting other parameters from config.
 
         Valid kwargs include:
 
         'radecCenter', an afw.geom.SpherePoint giving the ICRS RA,Dec position
            of the center of the field.  This is used to limit the
            search done by Astrometry.net (to make it faster and load
            fewer index files, thereby using less memory).  Defaults to
            the RA,Dec center from the exposure's WCS; turn that off
            with the boolean kwarg 'useRaDecCenter' or config option
            'useWcsRaDecCenter'
 
         'useRaDecCenter', a boolean.  Don't use the RA,Dec center from
            the exposure's initial WCS.
 
         'searchRadius', in degrees, to search for a solution around
            the given 'radecCenter'; default from config option
            'raDecSearchRadius'.
 
         'useParity': parity is the 'flip' of the image.  Knowing it
            reduces the search space (hence time) for Astrometry.net.
            The parity can be computed from the exposure's WCS (the
            sign of the determinant of the CD matrix); this option
            controls whether we do that or force Astrometry.net to
            search both parities.  Default from config.useWcsParity.
 
         'pixelScale': geom.Angle, estimate of the angle-per-pixel
            (ie, arcseconds per pixel).  Defaults to a value derived
            from the exposure's WCS.  If enabled, this value, plus or
            minus config.pixelScaleUncertainty, will be used to limit
            Astrometry.net's search.
 
         'usePixelScale': boolean.  Use the pixel scale to limit
            Astrometry.net's search?  Defaults to config.useWcsPixelScale.
 
         'filterName', a string, the filter name of this image.  Will
            be mapped through the 'filterMap' config dictionary to a
            column name in the astrometry_net_data index FITS files.
            Defaults to the exposure.getFilter() value.
 
         'bbox', bounding box of exposure; defaults to exposure.getBBox()
 
         """
         assert(exposure is not None)
 
         margs = kwargs.copy()
         if 'searchRadius' not in margs:
             margs.update(searchRadius=self.config.raDecSearchRadius * geom.degrees)
         if 'usePixelScale' not in margs:
             margs.update(usePixelScale=self.config.useWcsPixelScale)
         if 'useRaDecCenter' not in margs:
             margs.update(useRaDecCenter=self.config.useWcsRaDecCenter)
         if 'useParity' not in margs:
             margs.update(useParity=self.config.useWcsParity)
         margs.update(exposure=exposure)
         return self.determineWcs2(sourceCat=sourceCat, **margs)
 

◆ determineWcs2()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.determineWcs2	(	self,
		sourceCat,
		kwargs
	)

Get a blind astrometric solution for the given catalog of sources.

We need:
  -the image size;
  -the filter

And if available, we can use:
  -an initial Wcs estimate;
     --> RA,Dec center
     --> pixel scale
     --> "parity"

(all of which are metadata of Exposure).

filterName: string
imageSize: (W,H) integer tuple/iterable
pixelScale: lsst.geom.Angle per pixel.
radecCenter: lsst.afw.coord.Coord

Definition at line 462 of file anetBasicAstrometry.py.

     def determineWcs2(self, sourceCat, **kwargs):
         """Get a blind astrometric solution for the given catalog of sources.
 
         We need:
           -the image size;
           -the filter
 
         And if available, we can use:
           -an initial Wcs estimate;
              --> RA,Dec center
              --> pixel scale
              --> "parity"
 
         (all of which are metadata of Exposure).
 
         filterName: string
         imageSize: (W,H) integer tuple/iterable
         pixelScale: lsst.geom.Angle per pixel.
         radecCenter: lsst.afw.coord.Coord
         """
         wcs, qa = self.getBlindWcsSolution(sourceCat, **kwargs)
         kw = {}
         # Keys passed to useKnownWcs
         for key in ['exposure', 'bbox', 'filterName']:
             if key in kwargs:
                 kw[key] = kwargs[key]
         astrom = self.useKnownWcs(sourceCat, wcs=wcs, **kw)
         astrom.solveQa = qa
         astrom.tanWcs = wcs
         return astrom
 

◆ getBlindWcsSolution()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.getBlindWcsSolution	(	self,
		sourceCat,
		exposure = `None`,
		wcs = `None`,
		bbox = `None`,
		radecCenter = `None`,
		searchRadius = `None`,
		pixelScale = `None`,
		filterName = `None`,
		doTrim = `False`,
		usePixelScale = `True`,
		useRaDecCenter = `True`,
		useParity = `True`,
		searchRadiusScale = `2.`
	)

Definition at line 505 of file anetBasicAstrometry.py.

                             searchRadiusScale=2.):
         if not useRaDecCenter and radecCenter is not None:
             raise RuntimeError('radecCenter is set, but useRaDecCenter is False.  Make up your mind!')
         if not usePixelScale and pixelScale is not None:
             raise RuntimeError('pixelScale is set, but usePixelScale is False.  Make up your mind!')
 
         bbox, wcs, filterName = self._getImageParams(
             exposure=exposure,
             bbox=bbox,
             wcs=wcs,
             filterName=filterName,
             wcsRequired=False,
         )
 
         bboxD = geom.Box2D(bbox)
         xc, yc = bboxD.getCenter()
         parity = None
 
         if wcs is not None:
             if pixelScale is None:
                 if usePixelScale:
                     pixelScale = wcs.getPixelScale()
                     self.log.debug('Setting pixel scale estimate = %.3f from given WCS estimate',
                                    pixelScale.asArcseconds())
 
             if radecCenter is None:
                 if useRaDecCenter:
                     radecCenter = wcs.pixelToSky(xc, yc)
                     self.log.debug('Setting RA,Dec center estimate = (%.3f, %.3f) from given WCS '
                                    'estimate, using pixel center = (%.1f, %.1f)',
                                    radecCenter.getLongitude().asDegrees(),
                                    radecCenter.getLatitude().asDegrees(), xc, yc)
 
             if searchRadius is None:
                 if useRaDecCenter:
                     assert(pixelScale is not None)
                     pixRadius = math.hypot(*bboxD.getDimensions()) / 2
                     searchRadius = (pixelScale * pixRadius * searchRadiusScale)
                     self.log.debug('Using RA,Dec search radius = %.3f deg, from pixel scale, '
                                    'image size, and searchRadiusScale = %g',
                                    searchRadius, searchRadiusScale)
             if useParity:
                 parity = wcs.isFlipped
                 self.log.debug('Using parity = %s' % (parity and 'True' or 'False'))
 
         if doTrim:
             n = len(sourceCat)
             if exposure is not None:
                 exposureBBoxD = geom.Box2D(exposure.getMaskedImage().getBBox())
             else:
                 exposureBBoxD = bboxD
             sourceCat = self._trimBadPoints(sourceCat, exposureBBoxD)
             self.log.debug("Trimming: kept %i of %i sources", n, len(sourceCat))
 
         wcs, qa = self._solve(
             sourceCat=sourceCat,
             wcs=wcs,
             bbox=bbox,
             pixelScale=pixelScale,
             radecCenter=radecCenter,
             searchRadius=searchRadius,
             parity=parity,
             filterName=filterName,
         )
         if wcs is None:
             raise RuntimeError("Unable to match sources with catalog.")
         self.log.info('Got astrometric solution from Astrometry.net')
 
         rdc = wcs.pixelToSky(xc, yc)
         self.log.debug('New WCS says image center pixel (%.1f, %.1f) -> RA,Dec (%.3f, %.3f)',
                        xc, yc, rdc.getLongitude().asDegrees(), rdc.getLatitude().asDegrees())
         return wcs, qa
 

◆ getColumnName()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.getColumnName	(	self,
		filterName,
		columnMap,
		default = `None`
	)

Returns the column name in the astrometry_net_data index file that will be used
for the given filter name.

@param filterName   Name of filter used in exposure
@param columnMap    Dict that maps filter names to column names
@param default      Default column name

Definition at line 844 of file anetBasicAstrometry.py.

     def getColumnName(self, filterName, columnMap, default=None):
         """
         Returns the column name in the astrometry_net_data index file that will be used
         for the given filter name.
 
         @param filterName   Name of filter used in exposure
         @param columnMap    Dict that maps filter names to column names
         @param default      Default column name
         """
         filterName = self.config.filterMap.get(filterName, filterName)  # Exposure filter --> desired filter
         try:
             return columnMap[filterName]  # Desired filter --> a_n_d column name
         except KeyError:
             self.log.warn("No column in configuration for filter '%s'; using default '%s'" %
                           (filterName, default))
             return default
 

◆ getSipWcsFromCorrespondences()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.getSipWcsFromCorrespondences	(	self,
		origWcs,
		refCat,
		sourceCat,
		bbox
	)

Produce a SIP solution given a list of known correspondences.

Unlike _calculateSipTerms, this does not iterate the solution;
it assumes you have given it a good sets of corresponding stars.

NOTE that "refCat" and "sourceCat" are assumed to be the same length;
entries "refCat[i]" and "sourceCat[i]" are assumed to be correspondences.

@param[in] origWcs  the WCS to linearize in order to get the TAN part of the TAN-SIP WCS.
@param[in] refCat  reference source catalog
@param[in] sourceCat  source catalog
@param[in] bbox  bounding box of image

Definition at line 629 of file anetBasicAstrometry.py.

     def getSipWcsFromCorrespondences(self, origWcs, refCat, sourceCat, bbox):
         """Produce a SIP solution given a list of known correspondences.
 
         Unlike _calculateSipTerms, this does not iterate the solution;
         it assumes you have given it a good sets of corresponding stars.
 
         NOTE that "refCat" and "sourceCat" are assumed to be the same length;
         entries "refCat[i]" and "sourceCat[i]" are assumed to be correspondences.
 
         @param[in] origWcs  the WCS to linearize in order to get the TAN part of the TAN-SIP WCS.
         @param[in] refCat  reference source catalog
         @param[in] sourceCat  source catalog
         @param[in] bbox  bounding box of image
         """
         sipOrder = self.config.sipOrder
         matches = []
         for ci, si in zip(refCat, sourceCat):
             matches.append(afwTable.ReferenceMatch(ci, si, 0.))
 
         sipObject = astromSip.makeCreateWcsWithSip(matches, origWcs, sipOrder, bbox)
         return sipObject.getNewWcs()
 

◆ getSipWcsFromWcs()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.getSipWcsFromWcs	(	self,
		wcs,
		bbox,
		ngrid = `20`,
		linearizeAtCenter = `True`
	)

Get a TAN-SIP WCS, starting from an existing WCS.

It uses your WCS to compute a fake grid of corresponding "stars" in pixel and sky coords, and feeds that to the regular SIP code.

Parameters

[in]	wcs	initial WCS
[in]	bbox	bounding box of image
[in]	ngrid	number of grid points along x and y for fitting (fit at ngrid^2 points)
[in]	linearizeAtCenter	if True, get a linear approximation of the input WCS at the image center and use that as the TAN initialization for the TAN-SIP solution. You probably want this if your WCS has its CRPIX outside the image bounding box.

Definition at line 578 of file anetBasicAstrometry.py.

     def getSipWcsFromWcs(self, wcs, bbox, ngrid=20, linearizeAtCenter=True):
         """!Get a TAN-SIP WCS, starting from an existing WCS.
 
         It uses your WCS to compute a fake grid of corresponding "stars" in pixel and sky coords,
         and feeds that to the regular SIP code.
 
         @param[in] wcs  initial WCS
         @param[in] bbox  bounding box of image
         @param[in] ngrid  number of grid points along x and y for fitting (fit at ngrid^2 points)
         @param[in] linearizeAtCenter  if True, get a linear approximation of the input
           WCS at the image center and use that as the TAN initialization for
           the TAN-SIP solution.  You probably want this if your WCS has its
           CRPIX outside the image bounding box.
         """
         # Ugh, build src and ref tables
         srcSchema = afwTable.SourceTable.makeMinimalSchema()
         key = srcSchema.addField("centroid", type="PointD")
         srcTable = afwTable.SourceTable.make(srcSchema)
         srcTable.defineCentroid("centroid")
         srcs = srcTable
         refs = afwTable.SimpleTable.make(afwTable.SimpleTable.makeMinimalSchema())
         cref = []
         csrc = []
         (W, H) = bbox.getDimensions()
         x0, y0 = bbox.getMin()
         for xx in np.linspace(0., W, ngrid):
             for yy in np.linspace(0, H, ngrid):
                 src = srcs.makeRecord()
                 src.set(key.getX(), x0 + xx)
                 src.set(key.getY(), y0 + yy)
                 csrc.append(src)
                 rd = wcs.pixelToSky(xx + x0, yy + y0)
                 ref = refs.makeRecord()
                 ref.setCoord(rd)
                 cref.append(ref)
 
         if linearizeAtCenter:
             # Linearize the original WCS around the image center to create a
             # TAN WCS.
             # Reference pixel in LSST coords
             crpix = geom.Box2D(bbox).getCenter()
             crval = wcs.pixelToSky(crpix)
             crval = crval.getPosition(geom.degrees)
             # Linearize *AT* crval to get effective CD at crval.
             # (we use the default skyUnit of degrees as per WCS standard)
             aff = wcs.linearizePixelToSky(crval)
             cd = aff.getLinear().getMatrix()
             wcs = afwImage.Wcs(crval, crpix, cd)
 
         return self.getSipWcsFromCorrespondences(wcs, cref, csrc, (W, H), x0=x0, y0=y0)
 

◆ memusage()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.memusage	(	self,
		prefix = `''`
	)

Definition at line 276 of file anetBasicAstrometry.py.

     def memusage(self, prefix=''):
         # Not logging at DEBUG: do nothing
         if self.log.getLevel() > self.log.DEBUG:
             return
         from astrometry.util.ttime import get_memusage
         mu = get_memusage()
         ss = []
         for key in ['VmPeak', 'VmSize', 'VmRSS', 'VmData']:
             if key in mu:
                 ss.append(key + ': ' + ' '.join(mu[key]))
         if 'mmaps' in mu:
             ss.append('Mmaps: %i' % len(mu['mmaps']))
         if 'mmaps_total' in mu:
             ss.append('Mmaps: %i kB' % (mu['mmaps_total'] / 1024))
         self.log.debug(prefix + 'Memory: ' + ', '.join(ss))
 

◆ plotSolution()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.plotSolution	(	self,
		matches,
		wcs,
		imageSize
	)

Plot the solution, when debugging is turned on.

@param matches   The list of matches
@param wcs         The Wcs
@param imageSize   2-tuple with the image size (W,H)

Definition at line 712 of file anetBasicAstrometry.py.

     def plotSolution(self, matches, wcs, imageSize):
         """Plot the solution, when debugging is turned on.
 
         @param matches   The list of matches
         @param wcs         The Wcs
         @param imageSize   2-tuple with the image size (W,H)
         """
         import lsstDebug
         display = lsstDebug.Info(__name__).display
         if not display:
             return
 
         try:
             import matplotlib.pyplot as plt
         except ImportError as e:
             self.log.warn("Unable to import matplotlib: %s", e)
             return
 
         fig = plt.figure(1)
         fig.clf()
         try:
             fig.canvas._tkcanvas._root().lift()  # == Tk's raise, but raise is a python reserved word
         except Exception:                                 # protect against API changes
             pass
 
         num = len(matches)
         x = np.zeros(num)
         y = np.zeros(num)
         dx = np.zeros(num)
         dy = np.zeros(num)
         for i, m in enumerate(matches):
             x[i] = m.second.getX()
             y[i] = m.second.getY()
             pixel = wcs.skyToPixel(m.first.getCoord())
             dx[i] = x[i] - pixel.getX()
             dy[i] = y[i] - pixel.getY()
 
         subplots = maUtils.makeSubplots(fig, 2, 2, xgutter=0.1, ygutter=0.1, pygutter=0.04)
 
         def plotNext(x, y, xLabel, yLabel, xMax):
             ax = next(subplots)
             ax.set_autoscalex_on(False)
             ax.set_xbound(lower=0, upper=xMax)
             ax.scatter(x, y)
             ax.set_xlabel(xLabel)
             ax.set_ylabel(yLabel)
             ax.axhline(0.0)
 
         plotNext(x, dx, "x", "dx", imageSize[0])
         plotNext(x, dy, "x", "dy", imageSize[0])
         plotNext(y, dx, "y", "dx", imageSize[1])
         plotNext(y, dy, "y", "dy", imageSize[1])
 
         fig.show()
 
         while True:
             try:
                 reply = input("Pausing for inspection, enter to continue... [hpQ] ").strip()
             except EOFError:
                 reply = "n"
 
             reply = reply.split()
             if reply:
                 reply = reply[0]
             else:
                 reply = ""
 
             if reply in ("", "h", "p", "Q"):
                 if reply == "h":
                     print("h[elp] p[db] Q[uit]")
                     continue
                 elif reply == "p":
                     import pdb
                     pdb.set_trace()
                 elif reply == "Q":
                     sys.exit(1)
                 break
 

◆ useKnownWcs()

def lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.useKnownWcs	(	self,
		sourceCat,
		wcs = `None`,
		exposure = `None`,
		filterName = `None`,
		bbox = `None`,
		calculateSip = `None`
	)

Return an InitialAstrometry object, just like determineWcs, but assuming the given input WCS is correct.

This involves searching for reference sources within the WCS area, and matching them to the given 'sourceCat'. If 'calculateSip' is set, we will try to compute a TAN-SIP distortion correction.

Parameters

[in]	sourceCat	list of detected sources in this image.
[in]	wcs	your known WCS, or None to get from exposure
[in]	exposure	the exposure holding metadata for this image; if None then you must specify wcs, filterName and bbox
[in]	filterName	string, filter name, eg "i", or None to get from exposure`
[in]	bbox	bounding box of image, or None to get from exposure
[in]	calculateSip	calculate SIP distortion terms for the WCS? If None then use self.config.calculateSip. To disable WCS fitting set calculateSip=False

Note: this function is also called by 'determineWcs' (via 'determineWcs2'), since the steps are all the same.

Definition at line 323 of file anetBasicAstrometry.py.

     def useKnownWcs(self, sourceCat, wcs=None, exposure=None, filterName=None, bbox=None, calculateSip=None):
         """!Return an InitialAstrometry object, just like determineWcs,
         but assuming the given input WCS is correct.
 
         This involves searching for reference sources within the WCS
         area, and matching them to the given 'sourceCat'.  If
         'calculateSip' is set, we will try to compute a TAN-SIP
         distortion correction.
 
         @param[in] sourceCat  list of detected sources in this image.
         @param[in] wcs  your known WCS, or None to get from exposure
         @param[in] exposure  the exposure holding metadata for this image;
             if None then you must specify wcs, filterName and bbox
         @param[in] filterName  string, filter name, eg "i", or None to get from exposure`
         @param[in] bbox  bounding box of image, or None to get from exposure
         @param[in] calculateSip  calculate SIP distortion terms for the WCS? If None
             then use self.config.calculateSip. To disable WCS fitting set calculateSip=False
 
         @note this function is also called by 'determineWcs' (via 'determineWcs2'), since the steps are all
         the same.
         """
         # return value:
         astrom = InitialAstrometry()
 
         if calculateSip is None:
             calculateSip = self.config.calculateSip
 
         bbox, wcs, filterName = self._getImageParams(
             exposure=exposure,
             bbox=bbox,
             wcs=wcs,
             filterName=filterName,
             wcsRequired=True,
         )
         refCat = self.refObjLoader.loadPixelBox(
             bbox=bbox,
             wcs=wcs,
             filterName=filterName,
             photoCalib=None,
         ).refCat
         astrom.refCat = refCat
         catids = [src.getId() for src in refCat]
         uids = set(catids)
         self.log.debug('%i reference sources; %i unique IDs', len(catids), len(uids))
         matches = self._getMatchList(sourceCat, refCat, wcs)
         uniq = set([sm.second.getId() for sm in matches])
         if len(matches) != len(uniq):
             self.log.warn('The list of matched stars contains duplicate reference source IDs '
                           '(%i sources, %i unique ids)', len(matches), len(uniq))
         if len(matches) == 0:
             self.log.warn('No matches found between input sources and reference catalogue.')
             return astrom
 
         self.log.debug('%i reference objects match input sources using input WCS', len(matches))
         astrom.tanMatches = matches
         astrom.tanWcs = wcs
 
         srcids = [s.getId() for s in sourceCat]
         for m in matches:
             assert(m.second.getId() in srcids)
             assert(m.second in sourceCat)
 
         if calculateSip:
             sipwcs, matches = self._calculateSipTerms(wcs, refCat, sourceCat, matches, bbox=bbox)
             if sipwcs == wcs:
                 self.log.debug('Failed to find a SIP WCS better than the initial one.')
             else:
                 self.log.debug('%i reference objects match input sources using SIP WCS',
                                len(matches))
                 astrom.sipWcs = sipwcs
                 astrom.sipMatches = matches
 
         wcs = astrom.getWcs()
         # _getMatchList() modifies the source list RA,Dec coordinates.
         # Here, we make them consistent with the WCS we are returning.
         for src in sourceCat:
             src.updateCoord(wcs)
         astrom.matchMeta = _createMetadata(bbox, wcs, filterName)
         return astrom
 

Member Data Documentation

◆ config

lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.config

Definition at line 266 of file anetBasicAstrometry.py.

◆ ConfigClass

lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.ConfigClass = ANetBasicAstrometryConfig

static

Definition at line 247 of file anetBasicAstrometry.py.

◆ refObjLoader

lsst.meas.extensions.astrometryNet.anetBasicAstrometry.ANetBasicAstrometryTask.refObjLoader

Definition at line 268 of file anetBasicAstrometry.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/Linux64/meas_extensions_astrometryNet/18.1.0-3-g9bc06b8+7/python/lsst/meas/extensions/astrometryNet/anetBasicAstrometry.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ determineWcs()

◆ determineWcs2()

◆ getBlindWcsSolution()

◆ getColumnName()

◆ getSipWcsFromCorrespondences()

◆ getSipWcsFromWcs()

◆ memusage()

◆ plotSolution()

◆ useKnownWcs()

Member Data Documentation

◆ config

◆ ConfigClass

◆ refObjLoader

◆ init()