lsst.afw.display Namespace Reference

Namespaces
namespace	ds9
namespace	ds9Regions
namespace	interface
namespace	rgb
namespace	utils
namespace	virtualDevice

Functions
	PYBIND11_MODULE (_simpleFits, mod)
	PYBIND11_MODULE (_rgb, mod)
template<typename ImageT >
void	replaceSaturatedPixels (ImageT &rim, ImageT &gim, ImageT &bim, int borderWidth, float saturatedPixelValue)
template void	replaceSaturatedPixels (image::MaskedImage< float > &rim, image::MaskedImage< float > &gim, image::MaskedImage< float > &bim, int borderWidth, float saturatedPixelValue)
template<class T >
std::pair< double, double >	getZScale (image::Image< T > const &image, int const nSamples=1000, double const contrast=0.25)
	Calculate an IRAF/ds9-style zscaling. More...
template std::pair< double, double >	getZScale (image::Image< std::uint16_t > const &image, int const nSamples, double const contrast)
template std::pair< double, double >	getZScale (image::Image< float > const &image, int const nSamples, double const contrast)
template<typename ImageT >
void	writeBasicFits (int fd, ImageT const &data, geom::SkyWcs const *Wcs, char const *title)
template<typename ImageT >
void	writeBasicFits (std::string const &filename, ImageT const &data, geom::SkyWcs const *Wcs, char const *title)
template<typename ImageT >
void	writeBasicFits (int fd, ImageT const &data, lsst::afw::geom::SkyWcs const *Wcs=nullptr, char const *title=nullptr)
template<typename ImageT >
void	writeBasicFits (std::string const &filename, ImageT const &data, lsst::afw::geom::SkyWcs const *Wcs=nullptr, const char *title=nullptr)

Function Documentation

getZScale() [1/3]

template std::pair< double, double > lsst::afw::display::getZScale	(	image::Image< float > const &	image,
		int const	nSamples,
		double const	contrast
	)

getZScale() [2/3]

template std::pair< double, double > lsst::afw::display::getZScale	(	image::Image< std::uint16_t > const &	image,
		int const	nSamples,
		double const	contrast
	)

getZScale() [3/3]

template<class T >

std::pair< double, double > lsst::afw::display::getZScale	(	image::Image< T > const &	image,
		int const	nSamples = 1000,
		double const	contrast = 0.25
	)

Calculate an IRAF/ds9-style zscaling.

To quote Frank Valdes (http://iraf.net/forum/viewtopic.php?showtopic=134139)

ZSCALE ALGORITHM

The zscale algorithm is designed to display the  image  values  near
the  median  image  value  without  the  time  consuming  process of
computing a full image histogram.  This is particularly  useful  for
astronomical  images  which  generally  have a very peaked histogram
corresponding to  the  background  sky  in  direct  imaging  or  the
continuum in a two dimensional spectrum.

The  sample  of pixels, specified by values greater than zero in the
sample mask zmask or by an  image  section,  is  selected  up  to  a
maximum  of nsample pixels.  If a bad pixel mask is specified by the
bpmask parameter then any pixels with mask values which are  greater
than  zero  are not counted in the sample.  Only the first pixels up
to the limit are selected where the order is by line beginning  from
the  first line.  If no mask is specified then a grid of pixels with
even spacing along lines and columns that  make  up  a  number  less
than or equal to the maximum sample size is used.

If  a  contrast of zero is specified (or the zrange flag is used and
the image does not have a  valid  minimum/maximum  value)  then  the
minimum  and maximum of the sample is used for the intensity mapping
range.

If the contrast  is  not  zero  the  sample  pixels  are  ranked  in
brightness  to  form  the  function  I(i) where i is the rank of the
pixel and I is its value.  Generally the midpoint of  this  function
(the  median) is very near the peak of the image histogram and there
is a well defined slope about the midpoint which is related  to  the
width  of the histogram.  At the ends of the I(i) function there are
a few very bright and dark pixels due to objects and defects in  the
field.   To  determine  the  slope  a  linear  function  is fit with
iterative rejection;

<code>
        I(i) = intercept + slope * (i - midpoint)
</code>

If more than half of the points are rejected then there is  no  well
defined  slope  and  the full range of the sample defines z1 and z2.
Otherwise the endpoints of the linear function  are  used  (provided
they are within the original range of the sample):

<code>
        z1 = I(midpoint) + (slope / contrast) * (1 - midpoint)
        z2 = I(midpoint) + (slope / contrast) * (npoints - midpoint)
</code>

As  can  be  seen,  the parameter contrast may be used to adjust the
contrast produced by this algorithm.

Parameters

image	The image we wish to stretch
nSamples	Number of samples to use
contrast	Stretch parameter; see description

Definition at line 167 of file _scaling.cc.

                                                                                                         {
    // extract samples
    std::vector<T> vSample;
    getSample(image, nSamples, vSample);
    int nPix = vSample.size();
 
    if (vSample.empty()) {
        throw LSST_EXCEPT(pex::exceptions::RuntimeError, "ZScale: No pixel in image is finite");
    }
 
    std::sort(vSample.begin(), vSample.end());
 
    // max, min, median
    // N.b. you can get a median in linear time, but we need the sorted array for fitLine()
    // If we wanted to speed this up, the best option would be to quantize
    // the pixel values and build a histogram
    double const zmin = vSample.front();
    double const zmax = vSample.back();
    int const iCenter = nPix / 2;
    T median = (nPix & 1) ? vSample[iCenter] : (vSample[iCenter] + vSample[iCenter + 1]) / 2;
 
    // fit a line to the sorted sample
    const int maxRejectionRatio = 2;
    const int npixelsMin = 5;
 
    int minpix = std::max(npixelsMin, nPix / maxRejectionRatio);
    int nGrow = std::max(1, nPix / 100);
 
    const double nSigmaClip = 2.5;
    const int nIterations = 5;
 
    int nGoodPix = 0;
    std::pair<double, double> ret = fitLine(&nGoodPix, vSample, nSigmaClip, nGrow, minpix, nIterations);
#if 0  // unused, but calculated and potentially useful
    double const zstart = ret.first;
#endif
    double const zslope = ret.second;
 
    double z1, z2;
    if (nGoodPix < minpix) {
        z1 = zmin;
        z2 = zmax;
    } else {
        double const slope = zslope / contrast;
 
        z1 = std::max(zmin, median - iCenter * slope);
        z2 = std::min(zmax, median + (nPix - iCenter - 1) * slope);
    }
 
    return std::make_pair(z1, z2);
}

PYBIND11_MODULE() [1/2]

lsst::afw::display::PYBIND11_MODULE	(	_rgb	,
		mod
	)

Definition at line 38 of file _rgb.cc.

                           {
    /* Module level */
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.display.rbg");
    wrappers.wrap([](auto &mod) {
        mod.def("replaceSaturatedPixels", replaceSaturatedPixels<lsst::afw::image::MaskedImage<float>>,
                "rim"_a, "gim"_a, "bim"_a, "borderWidth"_a = 2, "saturatedPixelValue"_a = 65535);
        mod.def("getZScale", getZScale<std::uint16_t>, "image"_a, "nsamples"_a = 1000, "contrast"_a = 0.25);
        mod.def("getZScale", getZScale<float>, "image"_a, "nsamples"_a = 1000, "contrast"_a = 0.25);
    });
    wrappers.finish();
}

PYBIND11_MODULE() [2/2]

lsst::afw::display::PYBIND11_MODULE	(	_simpleFits	,
		mod
	)

Definition at line 58 of file _simpleFits.cc.

                                  {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.display");
    declareAll<image::Image<std::uint16_t>>(wrappers);
    declareAll<image::Image<std::uint64_t>>(wrappers);
    declareAll<image::Image<int>>(wrappers);
    declareAll<image::Image<float>>(wrappers);
    declareAll<image::Image<double>>(wrappers);
    declareAll<image::Mask<std::uint16_t>>(wrappers);
    declareAll<image::Mask<image::MaskPixel>>(wrappers);
    wrappers.finish();
}

replaceSaturatedPixels() [1/2]

template void lsst::afw::display::replaceSaturatedPixels	(	image::MaskedImage< float > &	rim,
		image::MaskedImage< float > &	gim,
		image::MaskedImage< float > &	bim,
		int	borderWidth,
		float	saturatedPixelValue
	)

replaceSaturatedPixels() [2/2]

template<typename ImageT >

void lsst::afw::display::replaceSaturatedPixels	(	ImageT &	rim,
		ImageT &	gim,
		ImageT &	bim,
		int	borderWidth,
		float	saturatedPixelValue
	)

Definition at line 32 of file _saturated.cc.

  {
    int const width = rim.getWidth(), height = rim.getHeight();
    int const x0 = rim.getX0(), y0 = rim.getY0();
 
    if (width != gim.getWidth() || height != gim.getHeight() || x0 != gim.getX0() || y0 != gim.getY0()) {
        throw LSST_EXCEPT(
                pex::exceptions::InvalidParameterError,
                str(boost::format("R image has different size/origin from G image "
                                  "(%dx%d+%d+%d v. %dx%d+%d+%d") %
                    width % height % x0 % y0 % gim.getWidth() % gim.getHeight() % gim.getX0() % gim.getY0()));
    }
    if (width != bim.getWidth() || height != bim.getHeight() || x0 != bim.getX0() || y0 != bim.getY0()) {
        throw LSST_EXCEPT(
                pex::exceptions::InvalidParameterError,
                str(boost::format("R image has different size/origin from B image "
                                  "(%dx%d+%d+%d v. %dx%d+%d+%d") %
                    width % height % x0 % y0 % bim.getWidth() % bim.getHeight() % bim.getX0() % bim.getY0()));
    }
 
    bool const useMaxPixel = !std::isfinite(saturatedPixelValue);
 
    SetPixels<typename ImageT::Image> setR, setG, setB;  // functors used to set pixel values
 
    // Find all the saturated pixels in any of the three image
    int const npixMin = 1;  // minimum number of pixels in an object
    afw::image::MaskPixel const SAT = rim.getMask()->getPlaneBitMask("SAT");
    detection::Threshold const satThresh(SAT, detection::Threshold::BITMASK);
 
    detection::FootprintSet sat(*rim.getMask(), satThresh, npixMin);
    sat.merge(detection::FootprintSet(*gim.getMask(), satThresh, npixMin));
    sat.merge(detection::FootprintSet(*bim.getMask(), satThresh, npixMin));
    // go through the list of saturated regions, determining the mean colour of the surrounding pixels
    using FootprintList = detection::FootprintSet::FootprintList;
    std::shared_ptr<FootprintList> feet = sat.getFootprints();
    for (const auto& foot : *feet) {
        auto const bigFoot = std::make_shared<detection::Footprint>(foot->getSpans()->dilated(borderWidth),
                                                                    foot->getRegion());
 
        double sumR = 0, sumG = 0, sumB = 0;  // sum of all non-saturated adjoining pixels
        double maxR = 0, maxG = 0, maxB = 0;  // maximum of non-saturated adjoining pixels
 
        for (auto span : *bigFoot->getSpans()) {
            int const y = span.getY() - y0;
            if (y < 0 || y >= height) {
                continue;
            }
            int sx0 = span.getX0() - x0;
            if (sx0 < 0) {
                sx0 = 0;
            }
            int sx1 = span.getX1() - x0;
            if (sx1 >= width) {
                sx1 = width - 1;
            }
 
            for (typename ImageT::iterator rptr = rim.at(sx0, y), rend = rim.at(sx1 + 1, y),
                                           gptr = gim.at(sx0, y), bptr = bim.at(sx0, y);
                 rptr != rend; ++rptr, ++gptr, ++bptr) {
                if (!((rptr.mask() | gptr.mask() | bptr.mask()) & SAT)) {
                    float val = rptr.image();
                    sumR += val;
                    if (val > maxR) {
                        maxR = val;
                    }
 
                    val = gptr.image();
                    sumG += val;
                    if (val > maxG) {
                        maxG = val;
                    }
 
                    val = bptr.image();
                    sumB += val;
                    if (val > maxB) {
                        maxB = val;
                    }
                }
            }
        }
        // OK, we have the mean fluxes for the pixels surrounding this set of saturated pixels
        // so we can figure out the proper values to use for the saturated ones
        float R = 0, G = 0, B = 0;  // mean intensities
        if (sumR + sumB + sumG > 0) {
            if (sumR > sumG) {
                if (sumR > sumB) {
                    R = useMaxPixel ? maxR : saturatedPixelValue;
 
                    G = (R * sumG) / sumR;
                    B = (R * sumB) / sumR;
                } else {
                    B = useMaxPixel ? maxB : saturatedPixelValue;
                    R = (B * sumR) / sumB;
                    G = (B * sumG) / sumB;
                }
            } else {
                if (sumG > sumB) {
                    G = useMaxPixel ? maxG : saturatedPixelValue;
                    R = (G * sumR) / sumG;
                    B = (G * sumB) / sumG;
                } else {
                    B = useMaxPixel ? maxB : saturatedPixelValue;
                    R = (B * sumR) / sumB;
                    G = (B * sumG) / sumB;
                }
            }
        }
        // Now that we know R, G, and B we can fix the values
        setR.setValue(R);
        foot->getSpans()->applyFunctor(setR, *rim.getImage());
        setG.setValue(G);
        foot->getSpans()->applyFunctor(setG, *gim.getImage());
        setB.setValue(B);
        foot->getSpans()->applyFunctor(setB, *bim.getImage());
    }
}

writeBasicFits() [1/4]

template<typename ImageT >

void lsst::afw::display::writeBasicFits	(	int	fd,
		ImageT const &	data,
		geom::SkyWcs const *	Wcs,
		char const *	title
	)

Definition at line 356 of file simpleFits.cc.

  {
    /*
     * Allocate cards for FITS headers
     */
    std::list<Card> cards;
    /*
     * What sort if image is it?
     */
    int bitpix = lsst::afw::fits::getBitPix<typename ImageT::Pixel>();
    if (bitpix == 20) {  // cfitsio for "Unsigned short"
        cards.emplace_back("BZERO", 32768.0, "");
        cards.emplace_back("BSCALE", 1.0, "");
        bitpix = 16;
    } else if (bitpix == 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, "Unsupported image type");
    }
    /*
     * Generate WcsA, pixel coordinates, allowing for X0 and Y0
     */
    addWcs("A", cards, data.getX0(), data.getY0());
    /*
     * Now WcsB, so that pixel (0,0) is correctly labelled (but ignoring XY0)
     */
    addWcs("B", cards);
 
    if (title) {
        cards.emplace_back("OBJECT", title, "Image being displayed");
    }
    /*
     * Was there something else?
     */
    if (Wcs == nullptr) {
        addWcs("", cards);  // works around a ds9 bug that WCSA/B is ignored if no Wcs is present
    } else {
        using NameList = std::vector<std::string>;
 
        auto shift = lsst::geom::Extent2D(-data.getX0(), -data.getY0());
        auto newWcs = Wcs->copyAtShiftedPixelOrigin(shift);
 
        std::shared_ptr<lsst::daf::base::PropertySet> metadata = newWcs->getFitsMetadata();
 
        NameList paramNames = metadata->paramNames();
 
        for (auto const &paramName : paramNames) {
            if (paramName == "SIMPLE" || paramName == "BITPIX" || paramName == "NAXIS" || paramName == "NAXIS1" || paramName == "NAXIS2" ||
                paramName == "XTENSION" || paramName == "PCOUNT" || paramName == "GCOUNT") {
                continue;
            }
            std::type_info const &type = metadata->typeOf(paramName);
            if (type == typeid(bool)) {
                cards.emplace_back(paramName, metadata->get<bool>(paramName));
            } else if (type == typeid(int)) {
                cards.emplace_back(paramName, metadata->get<int>(paramName));
            } else if (type == typeid(float)) {
                cards.emplace_back(paramName, metadata->get<float>(paramName));
            } else if (type == typeid(double)) {
                cards.emplace_back(paramName, metadata->get<double>(paramName));
            } else {
                cards.emplace_back(paramName, metadata->get<std::string>(paramName));
            }
        }
    }
    /*
     * Basic FITS stuff
     */
    const int naxis = 2;  // == NAXIS
    int naxes[naxis];     /* values of NAXIS1 etc */
    naxes[0] = data.getWidth();
    naxes[1] = data.getHeight();
 
    write_fits_hdr(fd, bitpix, naxis, naxes, cards, 1);
    for (int y = 0; y != data.getHeight(); ++y) {
        if (write_fits_data(fd, bitpix, (char *)(data.row_begin(y)), (char *)(data.row_end(y))) < 0) {
            throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError,
                              (boost::format("Error writing data for row %d") % y).str());
        }
    }
 
    pad_to_fits_record(fd, data.getWidth() * data.getHeight(), bitpix);
}

writeBasicFits() [2/4]

template<typename ImageT >

void lsst::afw::display::writeBasicFits	(	int	fd,
		ImageT const &	data,
		lsst::afw::geom::SkyWcs const *	Wcs = nullptr,
		char const *	title = nullptr
	)

writeBasicFits() [3/4]

template<typename ImageT >

void lsst::afw::display::writeBasicFits	(	std::string const &	filename,
		ImageT const &	data,
		geom::SkyWcs const *	Wcs,
		char const *	title
	)

Definition at line 442 of file simpleFits.cc.

  {
    int fd;
    if ((filename.c_str())[0] == '|') {  // a command
        const char *cmd = filename.c_str() + 1;
        while (isspace(*cmd)) {
            cmd++;
        }
 
        fd = fileno(popen(cmd, "w"));
    } else {
        fd = creat(filename.c_str(), 777);
    }
 
    if (fd < 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError,
                          (boost::format("Cannot open \"%s\"") % filename).str());
    }
 
    try {
        writeBasicFits(fd, data, Wcs, title);
    } catch (lsst::pex::exceptions::Exception &) {
        (void)close(fd);
        throw;
    }
 
    (void)close(fd);
}

writeBasicFits() [4/4]

template<typename ImageT >

void lsst::afw::display::writeBasicFits	(	std::string const &	filename,
		ImageT const &	data,
		lsst::afw::geom::SkyWcs const *	Wcs = nullptr,
		const char *	title = nullptr
	)