Merge branch 'tickets/DM-3105'

python/lsst/afw/image/__init__.py

@@ -25,3 +25,4 @@
 import numpy
 from .imageLib import *
 from .basicUtils import *
+from .testUtils import *

tests/convolve.py

@@ -42,7 +42,6 @@
 import lsst.afw.image as afwImage
 import lsst.afw.math as afwMath
 import lsst.afw.math.detail as mathDetail
-import lsst.afw.image.testUtils as imTestUtils
 from kernel import makeDeltaFunctionKernelList, makeGaussianKernelList
 
 VERBOSITY = 0   # increase to see trace; 3 will show the convolutions specializations being used
@@ -153,7 +152,7 @@ def refConvolve(imMaskVar, xy0, kernel, doNormalize, doCopyEdge):
 
             retCol += 1
         retRow += 1
-    return (retImage.transpose(), retMask.transpose(), retVariance.transpose())
+    return [numpy.copy(numpy.transpose(arr), order="C") for arr in (retImage, retMask, retVariance)]
 
 def sameMaskPlaneDicts(maskedImageA, maskedImageB):
     """Return True if the mask plane dicts are the same, False otherwise.
@@ -172,7 +171,7 @@ def sameMaskPlaneDicts(maskedImageA, maskedImageB):
         return False
     return True
 
-class ConvolveTestCase(unittest.TestCase):
+class ConvolveTestCase(utilsTests.TestCase):
     def setUp(self):
         self.maskedImage = afwImage.MaskedImageF(FullMaskedImage, InputBBox, afwImage.LOCAL, True)
         # use a huge XY0 to make emphasize any errors related to not handling xy0 correctly.
@@ -223,43 +222,26 @@ def runBasicTest(self, kernel, convControl, refKernel=None, kernelDescr="", rtol
         xy0 = self.maskedImage.getXY0()
 
         refCnvImMaskVarArr = refConvolve(imMaskVar, xy0, refKernel, doNormalize, doCopyEdge)
+        refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
 
         afwMath.convolve(self.cnvImage, self.maskedImage.getImage(), kernel, convControl)
         self.assertEqual(self.cnvImage.getXY0(), self.xy0)
-        cnvImArr = self.cnvImage.getArray()
 
         afwMath.convolve(self.cnvMaskedImage, self.maskedImage, kernel, convControl)
-        cnvImMaskVarArr = self.cnvMaskedImage.getArrays()
 
         if display and False:
-            refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
             ds9.mtv(displayUtils.Mosaic().makeMosaic([
                 self.maskedImage, refMaskedImage, self.cnvMaskedImage]), frame=0)
             if False:
                 for (x, y) in ((0, 0), (1, 0), (0, 1), (50, 50)):
                     print "Mask(%d,%d) 0x%x 0x%x" % (x, y, refMaskedImage.getMask().get(x, y),
                     self.cnvMaskedImage.getMask().get(x, y))
 
-        errStr = imTestUtils.imagesDiffer(cnvImArr, refCnvImMaskVarArr[0], rtol=rtol, atol=atol)
-        if errStr:
-            self.cnvImage.writeFits("act%s.fits" % (shortKernelDescr,))
-            refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
-            refMaskedImage.getImage().writeFits("des%s.fits" % (shortKernelDescr,))
-            self.fail("convolve(Image, kernel=%s, doNormalize=%s, doCopyEdge=%s, maxInterpDist=%s) failed:\n%s" % \
-                (kernelDescr, doNormalize, doCopyEdge, maxInterpDist, errStr))
-
-        errStr = imTestUtils.maskedImagesDiffer(cnvImMaskVarArr, refCnvImMaskVarArr,
-            doVariance = True, rtol=rtol, atol=atol)
-        if errStr:
-            self.cnvMaskedImage.writeFits("act%s" % (shortKernelDescr,))
-            refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
-            refMaskedImage.writeFits("des%s" % (shortKernelDescr,))
-            self.fail("convolve(MaskedImage, kernel=%s, doNormalize=%s, doCopyEdge=%s, maxInterpDist=%s) failed:\n%s" % \
-                (kernelDescr, doNormalize, doCopyEdge, maxInterpDist, errStr))
+        self.assertImagesNearlyEqual(self.cnvImage, refMaskedImage.getImage(), atol=atol, rtol=rtol)
+        self.assertMaskedImagesNearlyEqual(self.cnvMaskedImage, refMaskedImage, atol=atol, rtol=rtol)
 
         if not sameMaskPlaneDicts(self.cnvMaskedImage, self.maskedImage):
             self.cnvMaskedImage.writeFits("act%s" % (shortKernelDescr,))
-            refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
             refMaskedImage.writeFits("des%s" % (shortKernelDescr,))
             self.fail("convolve(MaskedImage, kernel=%s, doNormalize=%s, doCopyEdge=%s, maxInterpDist=%s) failed:\n%s" % \
                 (kernelDescr, doNormalize, doCopyEdge, maxInterpDist, "convolved mask dictionary does not match input"))
@@ -329,16 +311,16 @@ def runBasicConvolveEdgeTest(self, kernel, kernelDescr):
         cnvMaskedImageGoodView[:] = cnvMaskedImageCopyViewOfGoodRegion
 
         # assert that these two are equal
-        cnvImMaskVarArr = cnvMaskedImage.getArrays()
-        desCnvImMaskVarArr = cnvMaskedImageCopy.getArrays()
-        errStr = imTestUtils.maskedImagesDiffer(cnvImMaskVarArr, desCnvImMaskVarArr,
-            doVariance = True, rtol=0, atol=0)
-        shortKernelDescr = kernelDescr.translate(NullTranslator, GarbageChars)
-        if errStr:
+        msg = "basicConvolve(MaskedImage, kernel=%s) wrote to edge pixels" % (kernelDescr,)
+        try:
+            self.assertMaskedImagesNearlyEqual(cnvMaskedImage, cnvMaskedImageCopy,
+                doVariance = True, rtol=0, atol=0, msg=msg)
+        except Exception:
+            # write out the images, then fail
+            shortKernelDescr = kernelDescr.translate(NullTranslator, GarbageChars)
             cnvMaskedImage.writeFits("actBasicConvolve%s" % (shortKernelDescr,))
             cnvMaskedImageCopy.writeFits("desBasicConvolve%s" % (shortKernelDescr,))
-            self.fail("basicConvolve(MaskedImage, kernel=%s) wrote to edge pixels:\n%s" % \
-                (kernelDescr, errStr))
+            raise
 
     def testConvolutionControl(self):
         """Test the ConvolutionControl object
@@ -369,28 +351,15 @@ def testUnityConvolution(self):
         doCopyEdge = False
 
         afwMath.convolve(self.cnvImage, self.maskedImage.getImage(), kernel, doNormalize, doCopyEdge)
-        cnvImArr = self.cnvImage.getArray()
 
         afwMath.convolve(self.cnvMaskedImage, self.maskedImage, kernel, doNormalize, doCopyEdge)
         cnvImMaskVarArr = self.cnvMaskedImage.getArrays()
-
-        refCnvImMaskVarArr = self.maskedImage.getArrays()
 
-        skipMaskArr = numpy.isnan(cnvImMaskVarArr[0])
+        skipMaskArr = numpy.array(numpy.isnan(cnvImMaskVarArr[0]), dtype=numpy.uint16)
 
         kernelDescr = "Centered DeltaFunctionKernel (testing unity convolution)"
-        errStr = imTestUtils.imagesDiffer(cnvImArr, refCnvImMaskVarArr[0], skipMaskArr=skipMaskArr)
-        if errStr:
-            self.fail("convolve(Image, kernel=%s, doNormalize=%s, doCopyEdge=%s) failed:\n%s" % \
-                (kernelDescr, doNormalize, doCopyEdge, errStr))
-        errStr = imTestUtils.maskedImagesDiffer(cnvImMaskVarArr, refCnvImMaskVarArr, skipMaskArr=skipMaskArr)
-        if errStr:
-            self.fail("convolve(MaskedImage, kernel=%s, doNormalize=%s, doCopyEdge=%s) failed:\n%s" % \
-                (kernelDescr, doNormalize, doCopyEdge, errStr))
-        self.assert_(sameMaskPlaneDicts(self.cnvMaskedImage, self.maskedImage),
-            "convolve(MaskedImage, kernel=%s, doNormalize=%s, doCopyEdge=%s) failed:\n%s" % \
-            (kernelDescr, doNormalize, doCopyEdge, "convolved mask dictionary does not match input"))
-
+        self.assertImagesNearlyEqual(self.cnvImage, self.maskedImage.getImage(), skipMask=skipMaskArr, msg=kernelDescr)
+        self.assertMaskedImagesNearlyEqual(self.cnvMaskedImage, self.maskedImage, skipMask=skipMaskArr, msg=kernelDescr)
 
     def testFixedKernelConvolve(self):
         """Test convolve with a fixed kernel

tests/kernel.py

@@ -435,7 +435,7 @@ def testMakeBadKernels(self):
                 try:
                     afwMath.DeltaFunctionKernel(kWidth, kHeight, afwGeom.Point2I(pointX, pointY))
                     self.fail("Should have failed with point not on kernel")
-                except pexExcept.Exception, e:
+                except pexExcept.Exception:
                     pass
 
 
@@ -625,7 +625,6 @@ def testZeroSizeKernel(self):
         Note: this ignores the default constructors, which produce kernels with height = width = 0.
         The default constructors are only intended to support persistence, not to produce useful kernels.
         """
-        emptyImage = afwImage.ImageF(afwGeom.Extent2I(0, 0))
         gaussFunc2D = afwMath.GaussianFunction2D(1.0, 1.0, 0.0)
         gaussFunc1D = afwMath.GaussianFunction1D(1.0)
         zeroPoint = afwGeom.Point2I(0, 0)
@@ -716,7 +715,7 @@ def basicTests(self, kernel, nKernelParams, nSpatialParams=0, dimMustMatch=True)
                 spatialParams = (spatialParamsForOneKernel,)*nkp
                 if ((nkp == nKernelParams) and ((nsp == nSpatialParams) or (nkp == 0))):
                     kernel.setSpatialParameters(spatialParams)
-                    self.assert_(numpy.alltrue(numpy.equal(kernel.getSpatialParameters(), spatialParams)))
+                    self.assert_(numpy.all(numpy.equal(kernel.getSpatialParameters(), spatialParams)))
                 else:
                     self.assertRaises(pexExcept.InvalidParameterError,
                         kernel.setSpatialParameters, spatialParams)
@@ -747,7 +746,7 @@ def basicTestComputeImageRaise(self, kernel, doRaise, kernelDescr=""):
             kernel.computeImage(kImage, True)
             if doRaise:
                 self.fail(kernelDescr + ".computeImage should have raised an exception")
-        except pexExcept.Exception, e:
+        except pexExcept.Exception:
             if not doRaise:
                 self.fail(kernelDescr + ".computeImage should not have raised an exception")
 

tests/kernelImagesForRegion.py

@@ -33,7 +33,6 @@
 import lsst.afw.image as afwImage
 import lsst.afw.math as afwMath
 import lsst.afw.math.detail as mathDetail
-import lsst.afw.image.testUtils as imTestUtils
 
 VERBOSITY = 0 # increase to see trace
 
@@ -50,7 +49,7 @@
 
 NameLocDict = dict((name, loc) for (loc, name) in LocNameDict.iteritems())
 
-class KernelImagesForRegion(unittest.TestCase):
+class KernelImagesForRegion(utilsTests.TestCase):
     def setUp(self):
         boxCorner = afwGeom.Point2I(11, 50)
         boxExtent = afwGeom.Extent2I(100, 99)
@@ -218,13 +217,10 @@ def testExactImages(self):
                 xPos = afwImage.indexToPosition(pixelIndex[0] + self.xy0[0])
                 yPos = afwImage.indexToPosition(pixelIndex[1] + self.xy0[1])
                 self.kernel.computeImage(desImage, doNormalize, xPos, yPos)
-                desImArr = desImage.getArray().transpose().copy()
 
                 actImage = region.getImage(location)
-                actImArr = actImage.getArray().transpose().copy()
-                errStr = imTestUtils.imagesDiffer(actImArr, desImArr)
-                if errStr:
-                    self.fail("exact image(%s) incorrect:\n%s" % (LocNameDict[location], errStr))
+                msg = "exact image(%s) incorrect" % (LocNameDict[location],)
+                self.assertImagesNearlyEqual(actImage, desImage, msg=msg)
 
 
 #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

tests/scaledPlus.py

@@ -30,15 +30,14 @@
 import lsst.afw.geom as afwGeom
 import lsst.afw.image as afwImage
 import lsst.afw.math as afwMath
-import lsst.afw.image.testUtils as imTestUtils
 
 VERBOSITY = 0 # increase to see trace
 
 pexLog.Debug("lsst.afw", VERBOSITY)
 
 #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
-class ScaledPlus(unittest.TestCase):
+class ScaledPlus(utilsTests.TestCase):
     def setUp(self):
         self.random = afwMath.Random()
         self.imWidth = 200
@@ -64,34 +63,25 @@ def runScaledAddTest(self, coeff0, coeff1):
         - coeff0: coefficient of image 0
         - coeff1: coefficient of image 1
         """
-        im0ArrSet = self.maskedImage0.getArrays()
-        im1ArrSet = self.maskedImage1.getArrays()
-
         desMaskedImage = afwImage.MaskedImageF(self.maskedImage0.getDimensions())
         desMaskedImage[:] = self.maskedImage0
         desMaskedImage *= coeff0
         desMaskedImage.scaledPlus(coeff1, self.maskedImage1)
-        desImArrSet = desMaskedImage.getArrays()
 
         actMaskedImage = afwImage.MaskedImageF(afwGeom.Extent2I(self.imWidth, self.imHeight))
         afwMath.randomUniformImage(actMaskedImage.getImage(), self.random)
         afwMath.randomUniformImage(actMaskedImage.getVariance(), self.random)
 
         afwMath.scaledPlus(actMaskedImage, coeff0, self.maskedImage0, coeff1, self.maskedImage1)
-        actImArrSet = actMaskedImage.getArrays()
 
         actImage = afwImage.ImageF(afwGeom.Extent2I(self.imWidth, self.imHeight))
         afwMath.randomUniformImage(actImage, self.random)
         afwMath.scaledPlus(actImage, coeff0, self.maskedImage0.getImage(), coeff1, self.maskedImage1.getImage())
-        actImArr = actImage.getArray()
 
-        errStr = imTestUtils.imagesDiffer(actImArr, desImArrSet[0])
-        if errStr:
-            self.fail("scaledPlus failed in images; coeff0=%s, coeff1=%s:\n%s" % (coeff0, coeff1, errStr,))
-        errStr = imTestUtils.maskedImagesDiffer(actImArrSet, desImArrSet)
-        if errStr:
-            self.fail("scaledPlus failed on masked images; coeff0=%s, coeff1=%s:\n%s" %
-                (coeff0, coeff1, errStr,))
+        msg = "scaledPlus failed for images; coeff0=%s, coeff1=%s" % (coeff0, coeff1)
+        self.assertImagesNearlyEqual(actImage, desMaskedImage.getImage(), msg=msg)
+        msg = "scaledPlus failed for masked images; coeff0=%s, coeff1=%s" % (coeff0, coeff1)
+        self.assertMaskedImagesNearlyEqual(actMaskedImage, desMaskedImage, msg=msg)
 
     def testScaledPlus(self):
         for coeff0 in (0.0, -0.1e-5, 0.1e-5, 1.0e3):