def testPolynomialFunction1D(self):
def basic1DPoly(x, params):
ii = len(params) - 1
retVal = params[ii]
while ii > 0:
ii -= 1
retVal = retVal * x + params[ii]
return retVal
maxOrder = 4
deltaParam = 0.3
errMsg = "{} = {} != {} for x={}, params={}; {}"
# test value using order constructor
for order in range(maxOrder):
numParams = order + 1
params = nrange(numParams, deltaParam, deltaParam)
f = afwMath.PolynomialFunction1D(params)
g = afwMath.PolynomialFunction1D(order)
g.setParameters(params)
h = f.clone()
self.assertEqual(f.getOrder(), order)
self.assertEqual(g.getOrder(), order)
for x in np.arange(-10.0, 10.1, 1.0):
predVal = basic1DPoly(x, params)
msg = errMsg.format(
type(f).__name__, f(x), predVal, x, params,
"params constructor")
self.assertFloatsAlmostEqual(f(x),
predVal,
msg=msg,
atol=self.atol,
rtol=None)
msg = errMsg.format(
type(g).__name__, g(x), predVal, x, params,
"order constructor")
self.assertFloatsAlmostEqual(g(x),
predVal,
msg=msg,
atol=self.atol,
rtol=None)
msg = errMsg.format(
type(h).__name__, h(x), predVal, x, params, "clone")
self.assertFloatsAlmostEqual(h(x),
predVal,
msg=msg,
atol=self.atol,
rtol=None)
def testCast(self):
instances = []
kVec = makeGaussianKernelList(9, 9, [(2.0, 2.0, 0.0)])
kParams = [0.0] * len(kVec)
instances.append(afwMath.LinearCombinationKernel(kVec, kParams))
instances.append(
afwMath.AnalyticKernel(7, 7,
afwMath.GaussianFunction2D(2.0, 2.0, 0.0)))
instances.append(
afwMath.DeltaFunctionKernel(5, 5, afwGeom.Point2I(1, 1)))
instances.append(
afwMath.FixedKernel(afwImage.ImageD(afwGeom.Extent2I(7, 7))))
instances.append(
afwMath.SeparableKernel(3, 3, afwMath.PolynomialFunction1D(0),
afwMath.PolynomialFunction1D(0)))
for instance in instances:
Class = type(instance)
base = instance.clone()
self.assertEqual(type(base), afwMath.Kernel)
derived = Class.cast(base)
self.assertEqual(type(derived), Class)
def testPolynomialFunction1D(self):
"""A test for PolynomialFunction1D
"""
def basic1DPoly(x, params):
"""1-dimensional polynomial function"""
ii = len(params) - 1
retVal = params[ii]
while ii > 0:
ii -= 1
retVal = retVal * x + params[ii]
return retVal
maxOrder = 4
deltaParam = 0.3
# test value using order constructor
for order in range(maxOrder):
numParams = order + 1
params = nrange(numParams, deltaParam, deltaParam)
f = afwMath.PolynomialFunction1D(params)
g = afwMath.PolynomialFunction1D(order)
g.setParameters(params)
h = f.clone()
self.assertEqual(f.getOrder(), order)
self.assertEqual(g.getOrder(), order)
# self.assertEqual(h.getOrder(), order)
for x in numpy.arange(-10.0, 10.1, 1.0):
predVal = basic1DPoly(x, params)
if not numpy.allclose(predVal, f(x)):
self.fail("%s = %s != %s for x=%s, params=%s; params constructor" % \
(type(f).__name__, f(x), predVal, x, params))
if not numpy.allclose(predVal, g(x)):
self.fail("%s = %s != %s for x=%s, params=%s; order constructor" % \
(type(f).__name__, g(x), predVal, x, params))
if not numpy.allclose(predVal, h(x)):
self.fail("%s = %s != %s for x=%s, params=%s; clone" % \
(type(h).__name__, h(x), predVal, x, params))
def testCast(self):
for instance in (afwMath.Chebyshev1Function1F(2),
afwMath.GaussianFunction1F(1.0),
afwMath.LanczosFunction1F(3),
afwMath.NullFunction1F(),
afwMath.PolynomialFunction1F(2)):
Class = type(instance)
base = instance.clone()
self.assertEqual(type(base), afwMath.Function1F)
derived = Class.cast(base)
self.assertEqual(type(derived), Class)
for instance in (afwMath.Chebyshev1Function1D(2),
afwMath.GaussianFunction1D(1.0),
afwMath.LanczosFunction1D(3),
afwMath.NullFunction1D(),
afwMath.PolynomialFunction1D(2)):
Class = type(instance)
base = instance.clone()
self.assertEqual(type(base), afwMath.Function1D)
derived = Class.cast(base)
self.assertEqual(type(derived), Class)
for instance in (afwMath.Chebyshev1Function2F(2),
afwMath.GaussianFunction2F(1.0, 1.0),
afwMath.DoubleGaussianFunction2F(1.0),
afwMath.LanczosFunction2F(3),
afwMath.NullFunction2F(),
afwMath.PolynomialFunction2F(2)):
Class = type(instance)
base = instance.clone()
self.assertEqual(type(base), afwMath.Function2F)
derived = Class.cast(base)
self.assertEqual(type(derived), Class)
for instance in (afwMath.Chebyshev1Function2D(2),
afwMath.GaussianFunction2D(1.0, 1.0),
afwMath.DoubleGaussianFunction2D(1.0),
afwMath.LanczosFunction2D(3),
afwMath.NullFunction2D(),
afwMath.PolynomialFunction2D(2)):
Class = type(instance)
base = instance.clone()
self.assertEqual(type(base), afwMath.Function2D)
derived = Class.cast(base)
self.assertEqual(type(derived), Class)
def testComputeImageRaise(self):
"""Test Kernel.computeImage raises OverflowException iff doNormalize True and kernel sum exactly 0
"""
kWidth = 4
kHeight = 3
polyFunc1 = afwMath.PolynomialFunction1D(0)
polyFunc2 = afwMath.PolynomialFunction2D(0)
analKernel = afwMath.AnalyticKernel(kWidth, kHeight, polyFunc2)
kImage = afwImage.ImageD(analKernel.getDimensions())
for coeff in (-1, -1e-99, 0, 1e99, 1):
analKernel.setKernelParameters([coeff])
analKernel.computeImage(kImage, False)
fixedKernel = afwMath.FixedKernel(kImage)
sepKernel = afwMath.SeparableKernel(
kWidth, kHeight, polyFunc1, polyFunc1)
sepKernel.setKernelParameters([coeff, coeff])
kernelList = []
kernelList.append(analKernel)
lcKernel = afwMath.LinearCombinationKernel(kernelList, [1])
self.assertFalse(lcKernel.isDeltaFunctionBasis())
doRaise = (coeff == 0)
self.basicTestComputeImageRaise(
analKernel, doRaise, "AnalyticKernel")
self.basicTestComputeImageRaise(
fixedKernel, doRaise, "FixedKernel")
self.basicTestComputeImageRaise(
sepKernel, doRaise, "SeparableKernel")
self.basicTestComputeImageRaise(
lcKernel, doRaise, "LinearCombinationKernel")
lcKernel.setKernelParameters([0])
self.basicTestComputeImageRaise(
lcKernel, True, "LinearCombinationKernel")
