lsst::ip::isr Namespace Reference

Namespaces
namespace	ampOffset
namespace	assembleCcdTask
namespace	brighterFatterKernel
namespace	calibType
namespace	crosstalk
namespace	defects
namespace	deferredCharge
namespace	fringe
namespace	isrFunctions
namespace	isrMock
namespace	isrQa
namespace	isrStatistics
namespace	isrTask
namespace	linearize
namespace	masking
namespace	overscan
namespace	photodiode
namespace	photodiodeCorrection
namespace	ptcDataset
namespace	straylight
namespace	transmissionCurve
namespace	version
namespace	vignette

Classes
class	CountMaskedPixels
	Remove all non-astronomical counts from the Chunk Exposure's pixels. More...

Functions
template<typename PixelT >
int	applyLookupTable (afw::image::Image< PixelT > &image, ndarray::Array< PixelT, 1, 1 > const &table, PixelT indOffset)
	Add the values in a lookup table to an image, e.g.
template<typename PixelT >
size_t	maskNans (afw::image::MaskedImage< PixelT > const &mi, afw::image::MaskPixel maskVal, afw::image::MaskPixel allow=0)
	Mask NANs in an image.
template<typename ImagePixelT >
std::vector< double >	fitOverscanImage (lsst::afw::image::MaskedImage< ImagePixelT > const &overscan, std::vector< std::string > badPixelMask, bool isTransposed)
	PYBIND11_MODULE (applyLookupTable, mod)
	PYBIND11_MODULE (isr, mod)
template int	applyLookupTable< float > (afw::image::Image< float > &, ndarray::Array< float, 1, 1 > const &, float)
template int	applyLookupTable< double > (afw::image::Image< double > &, ndarray::Array< double, 1, 1 > const &, double)
std::string	between (std::string &s, char ldelim, char rdelim)
template std::vector< double >	fitOverscanImage< int > (afw::image::MaskedImage< int > const &, std::vector< std::string > badPixelMask, bool isTransposed)
template std::vector< double >	fitOverscanImage< float > (afw::image::MaskedImage< float > const &, std::vector< std::string > badPixelMask, bool isTransposed)
template std::vector< double >	fitOverscanImage< double > (afw::image::MaskedImage< double > const &, std::vector< std::string > badPixelMask, bool isTransposed)
template size_t	maskNans< float > (afw::image::MaskedImage< float > const &, afw::image::MaskPixel, afw::image::MaskPixel)
template size_t	maskNans< double > (afw::image::MaskedImage< double > const &, afw::image::MaskPixel, afw::image::MaskPixel)
template size_t	maskNans< int > (afw::image::MaskedImage< int > const &, afw::image::MaskPixel, afw::image::MaskPixel)

Function Documentation

applyLookupTable()

template<typename PixelT >

int lsst::ip::isr::applyLookupTable	(	afw::image::Image< PixelT > &	image,
		ndarray::Array< PixelT, 1, 1 > const &	table,
		PixelT	indOffset
	)

Add the values in a lookup table to an image, e.g.

for non-linearity correction

The algorithm is as follows: numOutOfRange = 0 For each i,j of the image: lookupInd = int(indOffset + image[i,j]) if lookupInd not in range [0, table.size() - 1]: set lookupInd to nearest edge and increment numOutOfRange image[i,j] += table[lookupInd] return numOutOfRange

Parameters

[in,out]	image	image to which to add the values; modified in place
[in]	table	lookup table
[in]	indOffset	scalar added to image value before truncating to lookup column

Returns

the number of pixels whose values were out of range

Definition at line 35 of file applyLookupTable.cc.

  {
    if (table.size() == 0u) {
        throw LSST_EXCEPT(
            pex::exceptions::LengthError,
            "Lookup table has zero size."
        );
    }
    int numOutOfRange = 0;
    int const maxLookupCol = table.size() - 1;
    for (int col = 0, imHeight = image.getHeight(); col < imHeight; ++col) {
        for (auto imPtr = image.row_begin(col), end = image.row_end(col); imPtr != end; ++imPtr) {
            int lookupCol = indOffset + *imPtr;
            if (lookupCol < 0) {
                lookupCol = 0;
                ++numOutOfRange;
            } else if (lookupCol > maxLookupCol) {
                lookupCol = maxLookupCol;
                ++numOutOfRange;
            }
            *imPtr += table[lookupCol];
        }
    }
    return numOutOfRange;
}

applyLookupTable< double >()

template int lsst::ip::isr::applyLookupTable< double >	(	afw::image::Image< double > &	,
		ndarray::Array< double, 1, 1 > const &	,
		double
	)

applyLookupTable< float >()

template int lsst::ip::isr::applyLookupTable< float >	(	afw::image::Image< float > &	,
		ndarray::Array< float, 1, 1 > const &	,
		float
	)

between()

std::string lsst::ip::isr::between	(	std::string &	s,
		char	ldelim,
		char	rdelim
	)

Definition at line 98 of file Isr.cc.

                                                          {
    std::string::iterator b(s.begin());
    std::string::iterator e(s.end());
    std::string::iterator lp;
    std::string::iterator rp;
 
    std::string result;
 
    if((lp = std::find(b, e, ldelim)) != e)
        if((rp = std::find(++lp, e, rdelim)) != e)
            result = std::string(lp, rp);
 
    return result;
}

fitOverscanImage()

template<typename ImagePixelT >

std::vector< double > lsst::ip::isr::fitOverscanImage	(	lsst::afw::image::MaskedImage< ImagePixelT > const &	overscan,
		std::vector< std::string >	badPixelMask,
		bool	isTransposed
	)

This is transposed here to match the existing numpy-array ordering. This effectively transposes the image for us.

This is transposed here to match the existing numpy-array ordering. This effectively transposes the image for us.

Definition at line 53 of file Isr.cc.

  {
    typedef afw::image::MaskedImage<ImagePixelT> MaskedImage;
 
    const int height = overscan.getHeight();
    const int width  = overscan.getWidth();
 
    int length = height;
    if (isTransposed) {
        length = width;
    }
 
    std::vector<double> values(length);
 
    afw::math::StatisticsControl statControl;
    statControl.setAndMask(overscan.getMask()->getPlaneBitMask(badPixelMask));
 
    const int x0 = overscan.getX0();
    const int y0 = overscan.getY0();
    auto origin = geom::Point2I(x0, y0);
    geom::Extent2I shifter;
    geom::Extent2I extents;
    if (isTransposed) {
        shifter = geom::Extent2I(1, 0);
        extents = geom::Extent2I(1, height);
    } else {
        shifter = geom::Extent2I(0, 1);
        extents = geom::Extent2I(width, 1);
    }
 
    for (int x = 0; x < length; ++x) {
        MaskedImage mi = MaskedImage(overscan, geom::Box2I(origin, extents));
        values[x] = afw::math::makeStatistics(mi, afw::math::MEDIAN, statControl).getValue();
        origin.shift(shifter);
    }
    return values;
}

fitOverscanImage< double >()

template std::vector< double > lsst::ip::isr::fitOverscanImage< double >	(	afw::image::MaskedImage< double > const &	,
		std::vector< std::string >	badPixelMask,
		bool	isTransposed
	)

fitOverscanImage< float >()

template std::vector< double > lsst::ip::isr::fitOverscanImage< float >	(	afw::image::MaskedImage< float > const &	,
		std::vector< std::string >	badPixelMask,
		bool	isTransposed
	)

fitOverscanImage< int >()

template std::vector< double > lsst::ip::isr::fitOverscanImage< int >	(	afw::image::MaskedImage< int > const &	,
		std::vector< std::string >	badPixelMask,
		bool	isTransposed
	)

maskNans()

template<typename PixelT >

size_t lsst::ip::isr::maskNans	(	afw::image::MaskedImage< PixelT > const &	mi,
		afw::image::MaskPixel	maskVal,
		afw::image::MaskPixel	allow = 0
	)

Mask NANs in an image.

NANs in the image or variance that are not already masked by the 'allow' value are masked with the 'maskVal'.

Returns

Number of pixels masked

Parameters

mi	Input image
maskVal	Bit mask value to give a NaN
allow	Retain NANs with this bit mask (0 to mask all NANs)

Definition at line 35 of file Isr.cc.

{
    typedef typename afw::image::MaskedImage<PixelT>::x_iterator x_iterator;
    size_t nPix = 0;
    for (int y = 0; y != mi.getHeight(); ++y) {
        for (x_iterator ptr = mi.row_begin(y), end = mi.row_end(y); ptr != end; ++ptr) {
            if (!(ptr.mask() & allow) && (!std::isfinite(ptr.image()) ||
                                          !std::isfinite(ptr.variance()))) {
                nPix += 1;
                ptr.mask() |= maskVal;
            }
        }
    }
    return nPix;
}

maskNans< double >()

template size_t lsst::ip::isr::maskNans< double >	(	afw::image::MaskedImage< double > const &	,
		afw::image::MaskPixel	,
		afw::image::MaskPixel
	)

maskNans< float >()

template size_t lsst::ip::isr::maskNans< float >	(	afw::image::MaskedImage< float > const &	,
		afw::image::MaskPixel	,
		afw::image::MaskPixel
	)

maskNans< int >()

template size_t lsst::ip::isr::maskNans< int >	(	afw::image::MaskedImage< int > const &	,
		afw::image::MaskPixel	,
		afw::image::MaskPixel
	)

PYBIND11_MODULE() [1/2]

lsst::ip::isr::PYBIND11_MODULE	(	applyLookupTable	,
		mod
	)

Definition at line 45 of file applyLookupTable.cc.

                                       {
    declareApplyLookupTable<float>(mod);
    declareApplyLookupTable<double>(mod);
}

PYBIND11_MODULE() [2/2]

lsst::ip::isr::PYBIND11_MODULE	(	isr	,
		mod
	)

Definition at line 69 of file isr.cc.

                          {
    declareAll<float>(mod, "F");
    declareAll<double>(mod, "D");
    declareAll<int>(mod, "I");
}