Merge pull request #773 from lsst/tickets/DM-36099

Change 'filters' to 'bands' for multiband images and exposures

Author: fred3m

python/lsst/afw/detection/multiband.py

@@ -88,16 +88,16 @@ class MultibandFootprint(MultibandBase):
 
     Parameters
     ----------
-    filters : `list`
-        List of filter names.
+    bands : `list`
+        List of band names.
     singles : `list`
         A list of single band `HeavyFootprint` objects.
         Each `HeavyFootprint` should have the same `PeakCatalog`
         and the same `SpanSet`, however to save CPU cycles there
         is no internal check for consistency of the peak catalog.
     """
-    def __init__(self, filters, singles):
-        super().__init__(filters, singles)
+    def __init__(self, bands, singles):
+        super().__init__(bands, singles)
         # Ensure that all HeavyFootprints have the same SpanSet
         spans = singles[0].getSpans()
         if not all([heavy.getSpans() == spans for heavy in singles]):
@@ -109,13 +109,13 @@ def __init__(self, filters, singles):
         self._footprint = footprint
 
     @staticmethod
-    def fromArrays(filters, image, mask=None, variance=None, footprint=None, xy0=None, thresh=0, peaks=None):
+    def fromArrays(bands, image, mask=None, variance=None, footprint=None, xy0=None, thresh=0, peaks=None):
         """Create a `MultibandFootprint` from an `image`, `mask`, `variance`
 
         Parameters
         ----------
-        filters : `list`
-            List of filter names.
+        bands : `list`
+            List of band names.
         image: array
             An array to convert into `lsst.afw.detection.HeavyFootprint` objects.
             Only pixels above the `thresh` value for at least one band
@@ -155,18 +155,18 @@ def fromArrays(filters, image, mask=None, variance=None, footprint=None, xy0=Non
 
         if peaks is not None:
             footprint.setPeakCatalog(peaks)
-        mMaskedImage = MultibandMaskedImage.fromArrays(filters, image, mask, variance, imageBBox)
+        mMaskedImage = MultibandMaskedImage.fromArrays(bands, image, mask, variance, imageBBox)
         singles = [makeHeavyFootprint(footprint, maskedImage) for maskedImage in mMaskedImage]
-        return MultibandFootprint(filters, singles)
+        return MultibandFootprint(bands, singles)
 
     @staticmethod
-    def fromImages(filters, image, mask=None, variance=None, footprint=None, thresh=0, peaks=None):
+    def fromImages(bands, image, mask=None, variance=None, footprint=None, thresh=0, peaks=None):
         """Create a `MultibandFootprint` from an `image`, `mask`, `variance`
 
         Parameters
         ----------
-        filters : `list`
-            List of filter names.
+        bands : `list`
+            List of band names.
         image : `lsst.afw.image.MultibandImage`, or list of `lsst.afw.image.Image`
             A `lsst.afw.image.MultibandImage` (or collection of images in each band)
             to convert into `HeavyFootprint` objects.
@@ -196,12 +196,12 @@ def fromImages(filters, image, mask=None, variance=None, footprint=None, thresh=
 
         if peaks is not None:
             footprint.setPeakCatalog(peaks)
-        mMaskedImage = MultibandMaskedImage(filters, image, mask, variance)
+        mMaskedImage = MultibandMaskedImage(bands, image, mask, variance)
         singles = [makeHeavyFootprint(footprint, maskedImage) for maskedImage in mMaskedImage]
-        return MultibandFootprint(filters, singles)
+        return MultibandFootprint(bands, singles)
 
     @staticmethod
-    def fromMaskedImages(filters, maskedImages, footprint=None, thresh=0, peaks=None):
+    def fromMaskedImages(bands, maskedImages, footprint=None, thresh=0, peaks=None):
         """Create a `MultibandFootprint` from a list of `MaskedImage`
 
         See `fromImages` for a description of the parameters not listed below
@@ -222,7 +222,7 @@ def fromMaskedImages(filters, maskedImages, footprint=None, thresh=0, peaks=None
         image = [maskedImage.image for maskedImage in maskedImages]
         mask = [maskedImage.mask for maskedImage in maskedImages]
         variance = [maskedImage.variance for maskedImage in maskedImages]
-        return MultibandFootprint.fromImages(filters, image, mask, variance, footprint, thresh, peaks)
+        return MultibandFootprint.fromImages(bands, image, mask, variance, footprint, thresh, peaks)
 
     def getSpans(self):
         """Get the full `SpanSet`"""
@@ -252,7 +252,7 @@ def peaks(self):
         """`PeakCatalog` of the `MultibandFootprint`"""
         return self._footprint.getPeaks()
 
-    def _slice(self, filters, filterIndex, indices):
+    def _slice(self, bands, bandIndex, indices):
         """Slice the current object and return the result
 
         `MultibandFootprint` objects cannot be sliced along the image
@@ -261,14 +261,14 @@ def _slice(self, filters, filterIndex, indices):
         See `Multiband._slice` for a list of the parameters.
         """
         if len(indices) > 0:
-            raise IndexError("MultibandFootprints can only be sliced in the filter dimension")
+            raise IndexError("MultibandFootprints can only be sliced in the band dimension")
 
-        if isinstance(filterIndex, slice):
-            singles = self.singles[filterIndex]
+        if isinstance(bandIndex, slice):
+            singles = self.singles[bandIndex]
         else:
-            singles = [self.singles[idx] for idx in filterIndex]
+            singles = [self.singles[idx] for idx in bandIndex]
 
-        return MultibandFootprint(filters, singles)
+        return MultibandFootprint(bands, singles)
 
     def getImage(self, bbox=None, fill=np.nan, imageType=MultibandMaskedImage):
         """Convert a `MultibandFootprint` to a `MultibandImage`
@@ -306,7 +306,7 @@ def getImage(self, bbox=None, fill=np.nan, imageType=MultibandMaskedImage):
         else:
             raise TypeError("Expected imageType to be either MultibandImage or MultibandMaskedImage")
         maskedImages = [heavy.extractImage(fill, bbox, singleType) for heavy in self.singles]
-        mMaskedImage = imageType.fromImages(self.filters, maskedImages)
+        mMaskedImage = imageType.fromImages(self.bands, maskedImages)
         return mMaskedImage
 
     def clone(self, deep=True):
@@ -327,8 +327,8 @@ def clone(self, deep=True):
             for peak in self.footprint.getPeaks():
                 footprint.addPeak(peak.getX(), peak.getY(), peak.getValue())
             mMaskedImage = self.getImage()
-            filters = tuple([f for f in self.filters])
-            result = MultibandFootprint.fromMaskedImages(filters, mMaskedImage, footprint)
+            bands = tuple([f for f in self.bands])
+            result = MultibandFootprint.fromMaskedImages(bands, mMaskedImage, footprint)
         else:
-            result = MultibandFootprint(self.filters, self.singles)
+            result = MultibandFootprint(self.bands, self.singles)
         return result

python/lsst/afw/image/_exposure/_multiband.py

@@ -53,7 +53,7 @@ class IncompleteDataError(Exception):
         the PSF.
     """
     def __init__(self, bands, position, partialPsf):
-        missingBands = [band for band in bands if band not in partialPsf.filters]
+        missingBands = [band for band in bands if band not in partialPsf.bands]
 
         self.missingBands = missingBands
         self.position = position
@@ -66,7 +66,7 @@ def computePsfImage(psfModels, position, useKernelImage=True):
     """Get a multiband PSF image
 
     The PSF Image or PSF Kernel Image is computed for each band
-    and combined into a (filter, y, x) array.
+    and combined into a (band, y, x) array.
 
     Parameters
     ----------
@@ -125,36 +125,36 @@ class MultibandExposure(MultibandTripleBase):
 
     See `MultibandTripleBase` for parameter definitions.
     """
-    def __init__(self, filters, image, mask, variance, psfs=None):
-        super().__init__(filters, image, mask, variance)
+    def __init__(self, bands, image, mask, variance, psfs=None):
+        super().__init__(bands, image, mask, variance)
         if psfs is not None:
             for psf, exposure in zip(psfs, self.singles):
                 exposure.setPsf(psf)
 
     @staticmethod
-    def fromExposures(filters, singles):
+    def fromExposures(bands, singles):
         """Construct a MultibandImage from a collection of single band images
 
         see `tripleFromExposures` for a description of parameters
         """
         psfs = [s.getPsf() for s in singles]
-        return tripleFromSingles(MultibandExposure, filters, singles, psfs=psfs)
+        return tripleFromSingles(MultibandExposure, bands, singles, psfs=psfs)
 
     @staticmethod
-    def fromArrays(filters, image, mask, variance, bbox=None):
+    def fromArrays(bands, image, mask, variance, bbox=None):
         """Construct a MultibandExposure from a collection of arrays
 
         see `tripleFromArrays` for a description of parameters
         """
-        return tripleFromArrays(MultibandExposure, filters, image, mask, variance, bbox)
+        return tripleFromArrays(MultibandExposure, bands, image, mask, variance, bbox)
 
     @staticmethod
-    def fromKwargs(filters, filterKwargs, singleType=ExposureF, **kwargs):
+    def fromKwargs(bands, bandKwargs, singleType=ExposureF, **kwargs):
         """Build a MultibandImage from a set of keyword arguments
 
         see `makeTripleFromKwargs` for a description of parameters
         """
-        return makeTripleFromKwargs(MultibandExposure, filters, filterKwargs, singleType, **kwargs)
+        return makeTripleFromKwargs(MultibandExposure, bands, bandKwargs, singleType, **kwargs)
 
     def _buildSingles(self, image=None, mask=None, variance=None):
         """Make a new list of single band objects
@@ -184,7 +184,7 @@ def _buildSingles(self, image=None, mask=None, variance=None):
             variance = self.variance
 
         dtype = image.array.dtype
-        for f in self.filters:
+        for f in self.bands:
             maskedImage = MaskedImage(image=image[f], mask=mask[f], variance=variance[f], dtype=dtype)
             single = Exposure(maskedImage, dtype=dtype)
             singles.append(single)
@@ -227,7 +227,7 @@ def computePsfKernelImage(self, position):
         """Get a multiband PSF image
 
         The PSF Kernel Image is computed for each band
-        and combined into a (filter, y, x) array and stored
+        and combined into a (band, y, x) array and stored
         as `self._psfImage`.
         The result is not cached, so if the same PSF is expected
         to be used multiple times it is a good idea to store the
@@ -253,7 +253,7 @@ def computePsfImage(self, position=None):
         """Get a multiband PSF image
 
         The PSF Kernel Image is computed for each band
-        and combined into a (filter, y, x) array and stored
+        and combined into a (band, y, x) array and stored
         as `self._psfImage`.
         The result is not cached, so if the same PSF is expected
         to be used multiple times it is a good idea to store the
@@ -284,22 +284,22 @@ def getPsfs(self):
         psfs : `dict` of `lsst.afw.detection.Psf`
             The PSF in each band
         """
-        return {band: self[band].getPsf() for band in self.filters}
+        return {band: self[band].getPsf() for band in self.bands}
 
-    def _slice(self, filters, filterIndex, indices):
+    def _slice(self, bands, bandIndex, indices):
         """Slice the current object and return the result
 
         See `Multiband._slice` for a list of the parameters.
         This overwrites the base method to attach the PSF to
         each individual exposure.
         """
-        image = self.image._slice(filters, filterIndex, indices)
+        image = self.image._slice(bands, bandIndex, indices)
         if self.mask is not None:
-            mask = self._mask._slice(filters, filterIndex, indices)
+            mask = self._mask._slice(bands, bandIndex, indices)
         else:
             mask = None
         if self.variance is not None:
-            variance = self._variance._slice(filters, filterIndex, indices)
+            variance = self._variance._slice(bands, bandIndex, indices)
         else:
             variance = None
 
@@ -312,10 +312,10 @@ def _slice(self, filters, filterIndex, indices):
             return (image, mask, variance)
 
         _psfs = self.getPsfs()
-        psfs = [_psfs[band] for band in filters]
+        psfs = [_psfs[band] for band in bands]
 
         result = MultibandExposure(
-            filters=filters,
+            bands=bands,
             image=image,
             mask=mask,
             variance=variance,