lsst.afw.display Namespace Reference

Namespaces
	ds9
	ds9Regions
	interface
	rgb
	utils
	virtualDevice

Typedefs
typedef detection::FootprintSet::FootprintList	FootprintList

Functions
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...
	if (width!=gim.getWidth()||height!=gim.getHeight()||x0!=gim.getX0()||y0!=gim.getY0())
SetPixels< typename ImageT::Image > setR *	rim ()), setG(*gim.getImage()), setB(*bim.getImage()
sat	merge (detection::FootprintSet(*gim.getMask(), satThresh, npixMin))
	for (FootprintList::const_iterator ptr=feet->begin(), end=feet->end();ptr!=end;++ptr)
template void	replaceSaturatedPixels (image::MaskedImage< float > &rim, image::MaskedImage< float > &gim, image::MaskedImage< float > &bim, int borderWidth, float saturatedPixelValue)
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, image::Wcs const *Wcs, char const *title)
template<typename ImageT >
void	writeBasicFits (std::string const &filename, ImageT const &data, image::Wcs const *Wcs, char const *title)

Variables
template<typename ImageT >
void ImageT &	gim
template<typename ImageT >
void ImageT ImageT &	bim
template<typename ImageT >
void ImageT ImageT int	borderWidth = 2
template<typename ImageT >
void ImageT ImageT int float	saturatedPixelValue
template<typename ImageT >
void ImageT ImageT int float saturatedPixelValue int const	width = rim.getWidth()
template<typename ImageT >
void ImageT ImageT int float saturatedPixelValue int const	height = rim.getHeight()
int const	x0 = rim.getX0()
int const	y0 = rim.getY0()
bool const	useMaxPixel = !std::isfinite(saturatedPixelValue)
int const	npixMin = 1
afw::image::MaskPixel const	SAT = rim.getMask()->getPlaneBitMask("SAT")
detection::Threshold const	satThresh (SAT, detection::Threshold::BITMASK)
boost::shared_ptr< FootprintList >	feet = sat.getFootprints()

Typedef Documentation

typedef detection::FootprintSet::FootprintList lsst::afw::display.FootprintList

Examples:

spatialCellExample.cc.

Definition at line 80 of file saturated.cc.

Function Documentation

lsst::afw::display::for	(	FootprintList::const_iterator	ptr = feet->begin(),
		end	= feet->end(); ptr != end; ++ptr
	)

Examples:

spatialCellExample.cc.

Definition at line 82 of file saturated.cc.

                                                                                                {
        PTR(detection::Footprint) const foot = *ptr;
        PTR(detection::Footprint) const bigFoot = growFootprint(*foot, borderWidth);

        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 (detection::Footprint::SpanList::const_iterator sptr = bigFoot->getSpans().begin(),
                 send = bigFoot->getSpans().end(); sptr != send; ++sptr) {
            PTR(detection::Span) const span = *sptr;

            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); setR.apply(*foot);
        setG.setValue(G); setG.apply(*foot);
        setB.setValue(B); setB.apply(*foot);
    }

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 185 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);
}

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

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

lsst::afw::display::if

(

width!

= gim.getWidth() || height != gim.getHeight() || x0 != gim.getX0() || y0 != gim.getY0()

)

Definition at line 47 of file saturated.cc.

                                                                                                        {
        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()));

    }

sat lsst::afw::display::merge	(	detection::FootprintSet(*.	getMask,
		satThresh	,
		npixMin
	)

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

detection::FootprintSet sat * lsst::afw::display::rim

(

)

template<typename ImageT >

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

Definition at line 362 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.push_back(Card("BZERO",  32768.0, ""));
        cards.push_back(Card("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
     */
    std::string wcsName = "A";
    cards.push_back(Card(str(boost::format("CRVAL1%s") % wcsName),
                         data.getX0(), "(output) Column pixel of Reference Pixel"));
    cards.push_back(Card(str(boost::format("CRVAL2%s") % wcsName),
                         data.getY0(), "(output) Row pixel of Reference Pixel"));
    cards.push_back(Card(str(boost::format("CRPIX1%s") % wcsName), 1.0,
                         "Column Pixel Coordinate of Reference"));
    cards.push_back(Card(str(boost::format("CRPIX2%s") % wcsName), 1.0, "Row Pixel Coordinate of Reference"));
    cards.push_back(Card(str(boost::format("CTYPE1%s") % wcsName), "LINEAR", "Type of projection"));
    cards.push_back(Card(str(boost::format("CTYPE1%s") % wcsName), "LINEAR", "Type of projection"));
    cards.push_back(Card(str(boost::format("CUNIT1%s") % wcsName), "PIXEL", "Column unit"));
    cards.push_back(Card(str(boost::format("CUNIT2%s") % wcsName), "PIXEL", "Row unit"));
    /*
     * Now WcsB, so that pixel (0,0) is correctly labelled (but ignoring XY0)
     */
    wcsName = "B";
    cards.push_back(Card(str(boost::format("CRVAL1%s") % wcsName), 0,
                         "(output) Column pixel of Reference Pixel"));
    cards.push_back(Card(str(boost::format("CRVAL2%s") % wcsName), 0,
                         "(output) Row pixel of Reference Pixel"));
    cards.push_back(Card(str(boost::format("CRPIX1%s") % wcsName), 1.0,
                         "Column Pixel Coordinate of Reference"));
    cards.push_back(Card(str(boost::format("CRPIX2%s") % wcsName), 1.0, "Row Pixel Coordinate of Reference"));
    cards.push_back(Card(str(boost::format("CTYPE1%s") % wcsName), "LINEAR", "Type of projection"));
    cards.push_back(Card(str(boost::format("CTYPE1%s") % wcsName), "LINEAR", "Type of projection"));
    cards.push_back(Card(str(boost::format("CUNIT1%s") % wcsName), "PIXEL", "Column unit"));
    cards.push_back(Card(str(boost::format("CUNIT2%s") % wcsName), "PIXEL", "Row unit"));

    if (title) {
        cards.push_back(Card("OBJECT", title, "Image being displayed"));
    }
    /*
     * Was there something else?
     */
    if (Wcs != NULL) {
        typedef std::vector<std::string> NameList;

        image::Wcs::Ptr newWcs = Wcs->clone(); //Create a copy
        newWcs->shiftReferencePixel(-data.getX0(), -data.getY0());

        lsst::daf::base::PropertySet::Ptr metadata = newWcs->getFitsMetadata();

        NameList paramNames = metadata->paramNames();

        for (NameList::const_iterator i = paramNames.begin(), end = paramNames.end(); i != end; ++i) {
            if (*i == "SIMPLE" ||
                *i == "BITPIX" ||
                *i == "NAXIS" ||
                *i == "NAXIS1" ||
                *i == "NAXIS2" ||
                *i == "XTENSION" ||
                *i == "PCOUNT" ||
                *i == "GCOUNT"
               ) {
                continue;
            }
            std::type_info const &type = metadata->typeOf(*i);
            if (type == typeid(bool)) {
                cards.push_back(Card(*i, metadata->get<bool>(*i)));
            } else if (type == typeid(int)) {
                cards.push_back(Card(*i, metadata->get<int>(*i)));
            } else if (type == typeid(float)) {
                cards.push_back(Card(*i, metadata->get<float>(*i)));
            } else if (type == typeid(double)) {
                cards.push_back(Card(*i, metadata->get<double>(*i)));
            } else {
                cards.push_back(Card(*i, metadata->get<std::string>(*i)));
            }
        }
    }
    /*
     * 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);
}

template<typename ImageT >

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

Definition at line 477 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);
}

Variable Documentation

template<typename ImageT >

void ImageT ImageT & lsst::afw::display::bim

Definition at line 36 of file Rgb.h.

template<typename ImageT >

void ImageT ImageT int lsst::afw::display::borderWidth = 2

Definition at line 38 of file Rgb.h.

boost::shared_ptr< FootprintList > lsst::afw::display.feet = sat.getFootprints()

Examples:

footprintFunctor.cc.

Definition at line 81 of file saturated.cc.

template<typename ImageT >

void ImageT & lsst::afw::display::gim

Definition at line 36 of file Rgb.h.

template<typename ImageT >

void ImageT ImageT int float saturatedPixelValue int const lsst::afw::display.height = rim.getHeight()

Definition at line 44 of file saturated.cc.

int const lsst::afw::display.npixMin = 1

Examples:

spatialCellExample.cc.

Definition at line 72 of file saturated.cc.

afw::image::MaskPixel const lsst::afw::display.SAT = rim.getMask()->getPlaneBitMask("SAT")

Definition at line 73 of file saturated.cc.

detection::Threshold const lsst::afw::display.satThresh(SAT, detection::Threshold::BITMASK)

template<typename ImageT >

void ImageT ImageT int float lsst::afw::display.saturatedPixelValue

Initial value:

= 65535 
                      )

Definition at line 39 of file Rgb.h.

bool const lsst::afw::display.useMaxPixel = !std::isfinite(saturatedPixelValue)

Definition at line 64 of file saturated.cc.

template<typename ImageT >

void ImageT ImageT int float saturatedPixelValue int const lsst::afw::display.width = rim.getWidth()

Definition at line 44 of file saturated.cc.

int const lsst::afw::display.x0 = rim.getX0()

Examples:

imageStatistics.cc.

Definition at line 45 of file saturated.cc.

int const lsst::afw::display.y0 = rim.getY0()

Definition at line 45 of file saturated.cc.