lsst.shapelet.tests.ShapeletTestCase Class Reference

Inheritance diagram for lsst.shapelet.tests.ShapeletTestCase:

Public Member Functions
def	compareShapeletFunctions (self, a, b, rtolEllipse=1E-13, rtolCoeff=1E-13, atolEllipse=1E-14, atolCoeff=1E-14)
def	simplifyMultiShapeletFunction (self, msf)
def	compareMultiShapeletFunctions (self, a, b, simplify=True, rtolEllipse=1E-13, rtolCoeff=1E-13, atolEllipse=1E-14, atolCoeff=1E-14)
def	checkMoments (self, function, x, y, z)
def	checkConvolution (self, f1, f2)

Static Public Member Functions
def	makeUnitVector (i, n)
def	makeImage (function, x, y)
def	makeRandomShapeletFunction (order=2, zeroCenter=False, ellipse=None, scale=1.0)
def	makeRandomMultiShapeletFunction (nComponents=3, ellipse=None)

Detailed Description

Definition at line 38 of file tests.py.

Member Function Documentation

checkConvolution()

def lsst.shapelet.tests.ShapeletTestCase.checkConvolution	(		self,
			f1,
			f2
	)

Definition at line 140 of file tests.py.

    def checkConvolution(self, f1, f2):
        bbox = lsst.geom.Box2I(lsst.geom.Point2I(-50, -50), lsst.geom.Point2I(50, 50))
        i1 = lsst.afw.image.ImageD(bbox)
        f1.evaluate().addToImage(i1)
        self.assertFloatsAlmostEqual(i1.getArray().sum(), f1.evaluate().integrate(), rtol=1E-3)
        i2 = lsst.afw.image.ImageD(bbox)
        f2.evaluate().addToImage(i2)
        self.assertFloatsAlmostEqual(i2.getArray().sum(), f2.evaluate().integrate(), rtol=1E-3)
        fc1 = f1.convolve(f2)
        fc2 = f2.convolve(f1)
        ic1 = lsst.afw.image.ImageD(bbox)
        fc1.evaluate().addToImage(ic1)
        ic2 = lsst.afw.image.ImageD(bbox)
        fc2.evaluate().addToImage(ic2)
        self.assertFloatsAlmostEqual(ic1.getArray(), ic2.getArray())
        out = lsst.afw.image.ImageD(bbox)
        if scipy is None:
            print("Skipping convolution test; scipy could not be imported.")
            return
        # I'm using scipy.ndimage to convolve test images, because I can't figure
        # out how to make afw do it (afw can convolve images with kernels, but two similarly-sized
        # are apparently another matter; if I try to make a FixedKernel from one of the images,
        # I can't even make the operation commutative, let alone correct.
        scipy.ndimage.convolve(i1.getArray(), i2.getArray(), output=out.getArray(),
                               mode="constant", cval=0.0)
        self.assertFloatsAlmostEqual(out.getArray(), ic1.getArray(), rtol=1E-4, atol=1E-5)
        self.assertFloatsAlmostEqual(out.getArray(), ic2.getArray(), rtol=1E-4, atol=1E-5)
        return fc1, fc2

checkMoments()

def lsst.shapelet.tests.ShapeletTestCase.checkMoments	(		self,
			function,
			x,
			y,
			z
	)

Definition at line 114 of file tests.py.

    def checkMoments(self, function, x, y, z):
        gx, gy = numpy.meshgrid(x, y)
        m = z.sum()
        dipole = lsst.geom.Point2D((gx * z).sum() / m, (gy * z).sum() / m)
        gx -= dipole.getX()
        gy -= dipole.getY()
        quadrupole = lsst.afw.geom.ellipses.Quadrupole(
            (gx**2 * z).sum() / m,
            (gy**2 * z).sum() / m,
            (gx * gy * z).sum() / m
        )
        imageMoments = lsst.afw.geom.ellipses.Ellipse(quadrupole, dipole)
        shapeletMoments = function.evaluate().computeMoments()
        self.assertFloatsAlmostEqual(imageMoments.getCenter().getX(),
                                     shapeletMoments.getCenter().getX(), rtol=1E-3)
        self.assertFloatsAlmostEqual(imageMoments.getCenter().getY(),
                                     shapeletMoments.getCenter().getY(), rtol=1E-3)
        self.assertFloatsAlmostEqual(imageMoments.getCore().getIxx(),
                                     shapeletMoments.getCore().getIxx(), rtol=1E-3)
        self.assertFloatsAlmostEqual(imageMoments.getCore().getIyy(),
                                     shapeletMoments.getCore().getIyy(), rtol=1E-3)
        self.assertFloatsAlmostEqual(imageMoments.getCore().getIxy(),
                                     shapeletMoments.getCore().getIxy(), rtol=1E-3)
        integral = numpy.trapz(numpy.trapz(z, gx, axis=1), y, axis=0)
        self.assertFloatsAlmostEqual(integral, function.evaluate().integrate(), rtol=1E-3)
 

compareMultiShapeletFunctions()

def lsst.shapelet.tests.ShapeletTestCase.compareMultiShapeletFunctions	(		self,
			a,
			b,
			simplify = True,
			rtolEllipse = 1E-13,
			rtolCoeff = 1E-13,
			atolEllipse = 1E-14,
			atolCoeff = 1E-14
	)

Definition at line 104 of file tests.py.

                                      atolEllipse=1E-14, atolCoeff=1E-14):
        if simplify:
            a = self.simplifyMultiShapeletFunction(a)
            b = self.simplifyMultiShapeletFunction(b)
        self.assertEqual(len(a.getComponents()), len(b.getComponents()))
        for sa, sb in zip(a.getComponents(), b.getComponents()):
            self.compareShapeletFunctions(sa, sb, rtolEllipse=rtolEllipse, rtolCoeff=rtolCoeff,
                                          atolEllipse=atolEllipse, atolCoeff=atolCoeff)
 

compareShapeletFunctions()

def lsst.shapelet.tests.ShapeletTestCase.compareShapeletFunctions	(		self,
			a,
			b,
			rtolEllipse = 1E-13,
			rtolCoeff = 1E-13,
			atolEllipse = 1E-14,
			atolCoeff = 1E-14
	)

Definition at line 82 of file tests.py.

                                 atolEllipse=1E-14, atolCoeff=1E-14):
        self.assertEqual(a.getOrder(), b.getOrder())
        self.assertEqual(a.getBasisType(), b.getBasisType())
        self.assertFloatsAlmostEqual(a.getEllipse().getParameterVector(),
                                     b.getEllipse().getParameterVector(),
                                     rtol=rtolEllipse, atol=atolEllipse)
        self.assertFloatsAlmostEqual(a.getCoefficients(), b.getCoefficients(),
                                     rtol=rtolCoeff, atol=atolCoeff)
 

makeImage()

def lsst.shapelet.tests.ShapeletTestCase.makeImage (   function,   x,   y  )

static

Definition at line 47 of file tests.py.

    def makeImage(function, x, y):
        z = numpy.zeros((y.size, x.size), dtype=float)
        e = function.evaluate()
        for i, py in enumerate(y):
            for j, px in enumerate(x):
                z[i, j] = e(float(px), float(py))
        return z
 

makeRandomMultiShapeletFunction()

def lsst.shapelet.tests.ShapeletTestCase.makeRandomMultiShapeletFunction (   nComponents = 3,   ellipse = None  )

static

Definition at line 76 of file tests.py.

    def makeRandomMultiShapeletFunction(nComponents=3, ellipse=None):
        components = []
        for n in range(nComponents):
            components.append(ShapeletTestCase.makeRandomShapeletFunction(ellipse=ellipse))
        return lsst.shapelet.MultiShapeletFunction(components)
 

makeRandomShapeletFunction()

def lsst.shapelet.tests.ShapeletTestCase.makeRandomShapeletFunction (   order = 2,   zeroCenter = False,   ellipse = None,   scale = 1.0  )

static

Definition at line 56 of file tests.py.

    def makeRandomShapeletFunction(order=2, zeroCenter=False, ellipse=None, scale=1.0):
        center = lsst.geom.Point2D()
        if not zeroCenter:
            center = lsst.geom.Point2D(numpy.random.randn(), numpy.random.randn())
        if ellipse is None:
            ellipse = lsst.afw.geom.ellipses.Ellipse(
                lsst.afw.geom.ellipses.Axes(
                    float(numpy.random.uniform(low=1, high=2)),
                    float(numpy.random.uniform(low=1, high=2)),
                    float(numpy.random.uniform(low=0, high=numpy.pi))
                ),
                center
            )
        coefficients = numpy.random.randn(lsst.shapelet.computeSize(order))
        result = lsst.shapelet.ShapeletFunction(order, lsst.shapelet.HERMITE, coefficients)
        result.setEllipse(ellipse)
        result.getEllipse().scale(scale)
        return result
 

makeUnitVector()

def lsst.shapelet.tests.ShapeletTestCase.makeUnitVector (   i,   n  )

static

Definition at line 41 of file tests.py.

    def makeUnitVector(i, n):
        v = numpy.zeros(n, dtype=float)
        v[i] = 1.0
        return v
 

simplifyMultiShapeletFunction()

def lsst.shapelet.tests.ShapeletTestCase.simplifyMultiShapeletFunction	(		self,
			msf
	)

Definition at line 92 of file tests.py.

    def simplifyMultiShapeletFunction(self, msf):
        keep = []
        for s in msf.getComponents():
            if not numpy.allclose(s.getCoefficients(), 0.0):
                params = tuple(s.getEllipse().getParameterVector()) + tuple(s.getCoefficients())
                keep.append((params, s))
        msf = lsst.shapelet.MultiShapeletFunction()
        keep.sort(key=lambda t: t[0])
        for params, s in keep:
            msf.addComponent(s)
        return msf
 

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/shapelet/22.0.1-1-g8e32f31+297cba6710/python/lsst/shapelet/tests.py