lsst.obs.base.utils Namespace Reference

Classes
class	InitialSkyWcsError

Functions
def	createInitialSkyWcs (visitInfo, detector, flipX=False)
def	bboxFromIraf (irafBBoxStr)
def	getInstrument (instrumentName, registry=None)
def	setDottedAttr (item, name, value)
def	setDottedAttrs (item, attrs)

Function Documentation

bboxFromIraf()

def lsst.obs.base.utils.bboxFromIraf

(

irafBBoxStr

)

Return a Box2I corresponding to an IRAF-style BBOX

[x0:x1,y0:y1] where x0 and x1 are the one-indexed start and end columns, and correspondingly
y0 and y1 are the start and end rows.

Definition at line 85 of file utils.py.

def bboxFromIraf(irafBBoxStr):
    """Return a Box2I corresponding to an IRAF-style BBOX
 
    [x0:x1,y0:y1] where x0 and x1 are the one-indexed start and end columns, and correspondingly
    y0 and y1 are the start and end rows.
    """
 
    mat = re.search(r"^\[([-\d]+):([-\d]+),([-\d]+):([-\d]+)\]$", irafBBoxStr)
    if not mat:
        raise RuntimeError("Unable to parse IRAF-style bbox \"%s\"" % irafBBoxStr)
    x0, x1, y0, y1 = [int(_) for _ in mat.groups()]
 
    return geom.BoxI(geom.PointI(x0 - 1, y0 - 1), geom.PointI(x1 - 1, y1 - 1))
 
 

createInitialSkyWcs()

def lsst.obs.base.utils.createInitialSkyWcs	(		visitInfo,
			detector,
			flipX = False
	)

Create a SkyWcs from the telescope boresight and detector geometry.

A typical usecase for this is to create the initial WCS for a newly-read
raw exposure.


Parameters
----------
visitInfo : `lsst.afw.image.VisitInfo`
    Where to get the telescope boresight and rotator angle from.
detector : `lsst.afw.cameraGeom.Detector`
    Where to get the camera geomtry from.
flipX : `bool`, optional
    If False, +X is along W, if True +X is along E.

Returns
-------
skyWcs : `lsst.afw.geom.SkyWcs`
    The new composed WCS.

Raises
------
InitialSkyWcsError
    Raised if there is an error generating the SkyWcs, chained from the
    lower-level exception if available.

Definition at line 44 of file utils.py.

def createInitialSkyWcs(visitInfo, detector, flipX=False):
    """Create a SkyWcs from the telescope boresight and detector geometry.
 
    A typical usecase for this is to create the initial WCS for a newly-read
    raw exposure.
 
 
    Parameters
    ----------
    visitInfo : `lsst.afw.image.VisitInfo`
        Where to get the telescope boresight and rotator angle from.
    detector : `lsst.afw.cameraGeom.Detector`
        Where to get the camera geomtry from.
    flipX : `bool`, optional
        If False, +X is along W, if True +X is along E.
 
    Returns
    -------
    skyWcs : `lsst.afw.geom.SkyWcs`
        The new composed WCS.
 
    Raises
    ------
    InitialSkyWcsError
        Raised if there is an error generating the SkyWcs, chained from the
        lower-level exception if available.
    """
    if visitInfo.getRotType() != RotType.SKY:
        msg = (f"Cannot create SkyWcs from camera geometry: rotator angle defined using "
               f"RotType={visitInfo.getRotType()} instead of SKY.")
        raise InitialSkyWcsError(msg)
    orientation = visitInfo.getBoresightRotAngle()
    boresight = visitInfo.getBoresightRaDec()
    try:
        pixelsToFieldAngle = detector.getTransform(detector.makeCameraSys(PIXELS),
                                                   detector.makeCameraSys(FIELD_ANGLE))
    except lsst.pex.exceptions.InvalidParameterError as e:
        raise InitialSkyWcsError("Cannot compute PIXELS to FIELD_ANGLE Transform.") from e
    return makeSkyWcs(pixelsToFieldAngle, orientation, flipX, boresight)
 
 

getInstrument()

def lsst.obs.base.utils.getInstrument	(		instrumentName,
			registry = None
	)

Return an instance of a named instrument.

If the instrument name not is qualified (does not contain a '.') and a
butler registry is provided, this will attempt to load the instrument using
Instrument.fromName. Otherwise the instrument will be imported and
instantiated.

Parameters
----------
instrumentName : string
    The name or fully-qualified class name of an instrument.
registry : `lsst.daf.butler.Registry`, optional
    Butler registry to query to find information about the instrument, by
    default None

Returns
-------
Instrument subclass instance
    The instantiated instrument.

Raises
------
RuntimeError
    If the instrument can not be imported, instantiated, or obtained from
    the registry.
TypeError
    If the instrument is not a subclass of lsst.obs.base.Instrument.

Definition at line 100 of file utils.py.

def getInstrument(instrumentName, registry=None):
    """Return an instance of a named instrument.
 
    If the instrument name not is qualified (does not contain a '.') and a
    butler registry is provided, this will attempt to load the instrument using
    Instrument.fromName. Otherwise the instrument will be imported and
    instantiated.
 
    Parameters
    ----------
    instrumentName : string
        The name or fully-qualified class name of an instrument.
    registry : `lsst.daf.butler.Registry`, optional
        Butler registry to query to find information about the instrument, by
        default None
 
    Returns
    -------
    Instrument subclass instance
        The instantiated instrument.
 
    Raises
    ------
    RuntimeError
        If the instrument can not be imported, instantiated, or obtained from
        the registry.
    TypeError
        If the instrument is not a subclass of lsst.obs.base.Instrument.
    """
    if "." not in instrumentName and registry is not None:
        try:
            instr = Instrument.fromName(instrumentName, registry)
        except Exception as err:
            raise RuntimeError(
                f"Could not get instrument from name: {instrumentName}. Failed with exception: {err}")
    else:
        try:
            instr = doImport(instrumentName)
        except Exception as err:
            raise RuntimeError(f"Could not import instrument: {instrumentName}. Failed with exception: {err}")
        instr = instr()
    if not isinstance(instr, Instrument):
        raise TypeError(f"{instrumentName} is not an Instrument subclass.")
    return instr
 
 
#  TODO remove the impl in pipe_base? (NB this combines setDottedAtr AND the
# handling in ConfigValueAction.__call__)

setDottedAttr()

def lsst.obs.base.utils.setDottedAttr	(		item,
			name,
			value
	)

Set an instance attribute (like `setattr` but accepting hierarchical
names such as ``foo.bar.baz``) If the attribute can not be set as a string,
will attempt to set the attribute with the result of eval'ing the value.

Parameters
----------
item : obj
    Object whose attribute is to be set.
name : `str`
    Name of attribute to set.
value : obj
    New value for the attribute.

Notes
-----
For example if name is ``foo.bar.baz`` then ``item.foo.bar.baz``
is set to the specified value.

Raises
------
AttributeError
    If the item does not have a field specified by name that can be set.
RuntimeError
    If the value can not be set as a string or rendered by eval, or if
    there is an error setting the attribute with the rendered value.

Definition at line 148 of file utils.py.

def setDottedAttr(item, name, value):
    """Set an instance attribute (like `setattr` but accepting hierarchical
    names such as ``foo.bar.baz``) If the attribute can not be set as a string,
    will attempt to set the attribute with the result of eval'ing the value.
 
    Parameters
    ----------
    item : obj
        Object whose attribute is to be set.
    name : `str`
        Name of attribute to set.
    value : obj
        New value for the attribute.
 
    Notes
    -----
    For example if name is ``foo.bar.baz`` then ``item.foo.bar.baz``
    is set to the specified value.
 
    Raises
    ------
    AttributeError
        If the item does not have a field specified by name that can be set.
    RuntimeError
        If the value can not be set as a string or rendered by eval, or if
        there is an error setting the attribute with the rendered value.
    """
    subitem = item
    subnameList = name.split(".")
    for subname in subnameList[:-1]:
        subitem = getattr(subitem, subname)
    try:
        setattr(subitem, subnameList[-1], value)
    except AttributeError:
        raise AttributeError(f"No field: {name!r}")
    except Exception:
        try:
            v = eval(value, {})
        except Exception:
            raise RuntimeError(f"Cannot render {value!r} as a value for {name!r}")
        try:
            setattr(subitem, subnameList[-1], v)
        except Exception as e:
            raise RuntimeError(f"Cannot set config. {name}={value!r}: {e}")
 
 

setDottedAttrs()

def lsst.obs.base.utils.setDottedAttrs	(		item,
			attrs
	)

Definition at line 194 of file utils.py.

def setDottedAttrs(item, attrs):
    for name, value in attrs:
        setDottedAttr(item, name, value)