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)

Variables
double const	lpc_1_c1 = 0.7737
double const	lpc_1_c2 = -0.2737
double const	lpc_1s2_c1 = 0.7358
double const	lpc_1s2_c2 = -0.2358
double const	min2GaussianBias = -0.5641895835
	Mean value of the minimum of two N(0,1) variates. More...

Function Documentation

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 1967 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

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

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

Definition at line 49 of file Interp.h.

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

Definition at line 50 of file Interp.h.

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 55 of file Interp.h.

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

Definition at line 56 of file Interp.h.

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

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

Definition at line 60 of file Interp.h.