lsst::meas::algorithms::interp Namespace Reference

Functions
template<typename MaskedImageT>
std::pair< bool, typename MaskedImageT::Image::Pixel >	singlePixel (int x, int y, MaskedImageT const &image, bool horizontal, double minval)
	Return a boolean status (true: interpolation is OK) and the interpolated value for a pixel, ignoring pixels given by badmask.
	interpolateOverDefects (image, psf, badList, fallbackValue=0.0, useFallbackValueAtEdge=False, fwhm=1.0, useLegacyInterp=True, maskNameList=None, **kwargs)

Variables
double const	lpc_1_c1 = 0.7737
	LPC coefficients for sigma = 1, S/N = infty.
double const	lpc_1_c2 = -0.2737
double const	lpc_1s2_c1 = 0.7358
	LPC coefficients for sigma = 1/sqrt(2), S/N = infty.
double const	lpc_1s2_c2 = -0.2358
double const	min2GaussianBias = -0.5641895835
	Mean value of the minimum of two N(0,1) variates.

Function Documentation

interpolateOverDefects()

lsst.meas.algorithms.interp.interpolateOverDefects	(		image,
			psf,
			badList,
			fallbackValue = 0.0,
			useFallbackValueAtEdge = False,
			fwhm = 1.0,
			useLegacyInterp = True,
			maskNameList = None,
		**	kwargs )

Definition at line 7 of file interp.py.

):
    if useLegacyInterp:
        return legacyInterpolateOverDefects(
            image, psf, badList, fallbackValue, useFallbackValueAtEdge
        )
    else:
        gp = InterpolateOverDefectGaussianProcess(image, fwhm=fwhm,
                                                  defects=maskNameList, **kwargs)
        return gp.run()

singlePixel()

template<typename MaskedImageT>

std::pair< bool, typename MaskedImageT::Image::Pixel > lsst::meas::algorithms::interp::singlePixel	(	int	x,
		int	y,
		MaskedImageT const &	image,
		bool	horizontal,
		double	minval )

Return a boolean status (true: interpolation is OK) and the interpolated value for a pixel, ignoring pixels given by badmask.

Interpolation can either be vertical or horizontal

Note

: This is a pretty expensive routine, so use only after suitable thought.

Parameters

x	x: column coordinate of the pixel in question
y	y: row coordinate of the pixel in question
image	image: in this image
horizontal	horizontal: interpolate horizontally?
minval	minval: minimum acceptable value

Definition at line 2125 of file Interp.cc.

  {
#if defined(SDSS)
    BADCOLUMN defect; /* describe a bad column */
    PIX *data;        /* temp array to interpolate in */
    int i;
    int i0, i1;               /* data corresponds to range of
                                {row,col} == [i0,i1] */
    int ndata;                /* dimension of data */
    static int ndatamax = 40; /* largest allowable defect. XXX */
    int nrow, ncol;           /* == reg->n{row,col} */
    PIX *val;                 /* pointer to pixel (rowc, colc) */
    int z1, z2;               /* range of bad {row,columns} */
 
    shAssert(badmask != NULL && badmask->type == shTypeGetFromName("OBJMASK"));
    shAssert(reg != NULL && reg->type == TYPE_PIX);
    nrow = reg->nrow;
    ncol = reg->ncol;
 
    if (horizontal) {
        for (z1 = colc - 1; z1 >= 0; z1--) {
            if (!phPixIntersectMask(badmask, z1, rowc)) {
                break;
            }
        }
        z1++;
 
        for (z2 = colc + 1; z2 < ncol; z2++) {
            if (!phPixIntersectMask(badmask, z2, rowc)) {
                break;
            }
        }
        z2--;
 
        i0 = (z1 > 2) ? z1 - 2 : 0;               /* origin of available required data */
        i1 = (z2 < ncol - 2) ? z2 + 2 : ncol - 1; /* end of "      "   "    "  */
 
        if (i0 < 2 || i1 >= ncol - 2) { /* interpolation will fail */
            return (-1);                /* failure */
        }
 
        ndata = (i1 - i0 + 1);
        if (ndata > ndatamax) {
            return (-1); /* failure */
        }
 
        data = alloca(ndata * sizeof(PIX));
        for (i = i0; i <= i1; i++) {
            data[i - i0] = reg->ROWS[rowc][i];
        }
        val = &data[colc - i0];
    } else {
        for (z1 = rowc - 1; z1 >= 0; z1--) {
            if (!phPixIntersectMask(badmask, colc, z1)) {
                break;
            }
        }
        z1++;
 
        for (z2 = rowc + 1; z2 < nrow; z2++) {
            if (!phPixIntersectMask(badmask, colc, z2)) {
                break;
            }
        }
        z2--;
 
        i0 = (z1 > 2) ? z1 - 2 : 0;               /* origin of available required data */
        i1 = (z2 < nrow - 2) ? z2 + 2 : nrow - 1; /* end of "      "   "    "  */
 
        if (i0 < 2 || i1 >= ncol - 2) { /* interpolation will fail */
            return (-1);                /* failure */
        }
 
        ndata = (i1 - i0 + 1);
        if (ndata > ndatamax) {
            return (-1); /* failure */
        }
 
        data = alloca(ndata * sizeof(PIX));
        for (i = i0; i <= i1; i++) {
            data[i - i0] = reg->ROWS[i][colc];
        }
        val = &data[rowc - i0];
    }
 
    defect.x1 = z1 - i0;
    defect.x2 = z2 - i0;
    classify_defects(&defect, 1, ndata);
    do_defect(&defect, 1, data, ndata, minval);
 
    return (*val);
#endif
 
    return std::make_pair(false, std::numeric_limits<typename MaskedImageT::Image::Pixel>::min());
}

Variable Documentation

lpc_1_c1

double const lsst::meas::algorithms::interp::lpc_1_c1 = 0.7737

LPC coefficients for sigma = 1, S/N = infty.

Definition at line 51 of file Interp.h.

lpc_1_c2

double const lsst::meas::algorithms::interp::lpc_1_c2 = -0.2737

Definition at line 52 of file Interp.h.

lpc_1s2_c1

double const lsst::meas::algorithms::interp::lpc_1s2_c1 = 0.7358

LPC coefficients for sigma = 1/sqrt(2), S/N = infty.

These are the coeffs to use when interpolating at 45degrees to the row/column

Definition at line 57 of file Interp.h.

lpc_1s2_c2

double const lsst::meas::algorithms::interp::lpc_1s2_c2 = -0.2358

Definition at line 58 of file Interp.h.

min2GaussianBias

double const lsst::meas::algorithms::interp::min2GaussianBias = -0.5641895835

Mean value of the minimum of two N(0,1) variates.

Definition at line 62 of file Interp.h.