Coverage for python/lsst/ip/isr/linearize.py: 15%
222 statements
« prev ^ index » next coverage.py v7.1.0, created at 2023-02-05 18:17 -0800
« prev ^ index » next coverage.py v7.1.0, created at 2023-02-05 18:17 -0800
1#
2# LSST Data Management System
3# Copyright 2016 AURA/LSST.
4#
5# This product includes software developed by the
6# LSST Project (http://www.lsst.org/).
7#
8# This program is free software: you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation, either version 3 of the License, or
11# (at your option) any later version.
12#
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16# GNU General Public License for more details.
17#
18# You should have received a copy of the LSST License Statement and
19# the GNU General Public License along with this program. If not,
20# see <http://www.lsstcorp.org/LegalNotices/>.
21#
22import abc
23import numpy as np
25from astropy.table import Table
27import lsst.afw.math as afwMath
28from lsst.pipe.base import Struct
29from lsst.geom import Box2I, Point2I, Extent2I
30from .applyLookupTable import applyLookupTable
31from .calibType import IsrCalib
33__all__ = ["Linearizer",
34 "LinearizeBase", "LinearizeLookupTable", "LinearizeSquared",
35 "LinearizeProportional", "LinearizePolynomial", "LinearizeSpline", "LinearizeNone"]
38class Linearizer(IsrCalib):
39 """Parameter set for linearization.
41 These parameters are included in cameraGeom.Amplifier, but
42 should be accessible externally to allow for testing.
44 Parameters
45 ----------
46 table : `numpy.array`, optional
47 Lookup table; a 2-dimensional array of floats:
48 - one row for each row index (value of coef[0] in the amplifier)
49 - one column for each image value
50 To avoid copying the table the last index should vary fastest
51 (numpy default "C" order)
52 detector : `lsst.afw.cameraGeom.Detector`, optional
53 Detector object. Passed to self.fromDetector() on init.
54 log : `logging.Logger`, optional
55 Logger to handle messages.
56 kwargs : `dict`, optional
57 Other keyword arguments to pass to the parent init.
59 Raises
60 ------
61 RuntimeError :
62 Raised if the supplied table is not 2D, or if the table has fewer
63 columns than rows (indicating that the indices are swapped).
65 Notes
66 -----
67 The linearizer attributes stored are:
69 hasLinearity : `bool`
70 Whether a linearity correction is defined for this detector.
71 override : `bool`
72 Whether the detector parameters should be overridden.
73 ampNames : `list` [`str`]
74 List of amplifier names to correct.
75 linearityCoeffs : `dict` [`str`, `numpy.array`]
76 Coefficients to use in correction. Indexed by amplifier
77 names. The format of the array depends on the type of
78 correction to apply.
79 linearityType : `dict` [`str`, `str`]
80 Type of correction to use, indexed by amplifier names.
81 linearityBBox : `dict` [`str`, `lsst.geom.Box2I`]
82 Bounding box the correction is valid over, indexed by
83 amplifier names.
84 fitParams : `dict` [`str`, `numpy.array`], optional
85 Linearity fit parameters used to construct the correction
86 coefficients, indexed as above.
87 fitParamsErr : `dict` [`str`, `numpy.array`], optional
88 Uncertainty values of the linearity fit parameters used to
89 construct the correction coefficients, indexed as above.
90 fitChiSq : `dict` [`str`, `float`], optional
91 Chi-squared value of the linearity fit, indexed as above.
92 tableData : `numpy.array`, optional
93 Lookup table data for the linearity correction.
94 """
95 _OBSTYPE = "LINEARIZER"
96 _SCHEMA = 'Gen3 Linearizer'
97 _VERSION = 1.1
99 def __init__(self, table=None, **kwargs):
100 self.hasLinearity = False
101 self.override = False
103 self.ampNames = list()
104 self.linearityCoeffs = dict()
105 self.linearityType = dict()
106 self.linearityBBox = dict()
108 self.fitParams = dict()
109 self.fitParamsErr = dict()
110 self.fitChiSq = dict()
112 self.tableData = None
113 if table is not None:
114 if len(table.shape) != 2:
115 raise RuntimeError("table shape = %s; must have two dimensions" % (table.shape,))
116 if table.shape[1] < table.shape[0]:
117 raise RuntimeError("table shape = %s; indices are switched" % (table.shape,))
118 self.tableData = np.array(table, order="C")
120 super().__init__(**kwargs)
121 self.requiredAttributes.update(['hasLinearity', 'override',
122 'ampNames',
123 'linearityCoeffs', 'linearityType', 'linearityBBox',
124 'fitParams', 'fitParamsErr', 'fitChiSq',
125 'tableData'])
127 def updateMetadata(self, setDate=False, **kwargs):
128 """Update metadata keywords with new values.
130 This calls the base class's method after ensuring the required
131 calibration keywords will be saved.
133 Parameters
134 ----------
135 setDate : `bool`, optional
136 Update the CALIBDATE fields in the metadata to the current
137 time. Defaults to False.
138 kwargs :
139 Other keyword parameters to set in the metadata.
140 """
141 kwargs['HAS_LINEARITY'] = self.hasLinearity
142 kwargs['OVERRIDE'] = self.override
143 kwargs['HAS_TABLE'] = self.tableData is not None
145 super().updateMetadata(setDate=setDate, **kwargs)
147 def fromDetector(self, detector):
148 """Read linearity parameters from a detector.
150 Parameters
151 ----------
152 detector : `lsst.afw.cameraGeom.detector`
153 Input detector with parameters to use.
155 Returns
156 -------
157 calib : `lsst.ip.isr.Linearizer`
158 The calibration constructed from the detector.
159 """
160 self._detectorName = detector.getName()
161 self._detectorSerial = detector.getSerial()
162 self._detectorId = detector.getId()
163 self.hasLinearity = True
165 # Do not translate Threshold, Maximum, Units.
166 for amp in detector.getAmplifiers():
167 ampName = amp.getName()
168 self.ampNames.append(ampName)
169 self.linearityType[ampName] = amp.getLinearityType()
170 self.linearityCoeffs[ampName] = amp.getLinearityCoeffs()
171 self.linearityBBox[ampName] = amp.getBBox()
173 return self
175 @classmethod
176 def fromDict(cls, dictionary):
177 """Construct a calibration from a dictionary of properties
179 Parameters
180 ----------
181 dictionary : `dict`
182 Dictionary of properties
184 Returns
185 -------
186 calib : `lsst.ip.isr.Linearity`
187 Constructed calibration.
189 Raises
190 ------
191 RuntimeError
192 Raised if the supplied dictionary is for a different
193 calibration.
194 """
196 calib = cls()
198 if calib._OBSTYPE != dictionary['metadata']['OBSTYPE']:
199 raise RuntimeError(f"Incorrect linearity supplied. Expected {calib._OBSTYPE}, "
200 f"found {dictionary['metadata']['OBSTYPE']}")
202 calib.setMetadata(dictionary['metadata'])
204 calib.hasLinearity = dictionary.get('hasLinearity',
205 dictionary['metadata'].get('HAS_LINEARITY', False))
206 calib.override = dictionary.get('override', True)
208 if calib.hasLinearity:
209 for ampName in dictionary['amplifiers']:
210 amp = dictionary['amplifiers'][ampName]
211 calib.ampNames.append(ampName)
212 calib.linearityCoeffs[ampName] = np.array(amp.get('linearityCoeffs', [0.0]))
213 calib.linearityType[ampName] = amp.get('linearityType', 'None')
214 calib.linearityBBox[ampName] = amp.get('linearityBBox', None)
216 calib.fitParams[ampName] = np.array(amp.get('fitParams', [0.0]))
217 calib.fitParamsErr[ampName] = np.array(amp.get('fitParamsErr', [0.0]))
218 calib.fitChiSq[ampName] = amp.get('fitChiSq', np.nan)
220 calib.tableData = dictionary.get('tableData', None)
221 if calib.tableData:
222 calib.tableData = np.array(calib.tableData)
224 return calib
226 def toDict(self):
227 """Return linearity parameters as a dict.
229 Returns
230 -------
231 outDict : `dict`:
232 """
233 self.updateMetadata()
235 outDict = {'metadata': self.getMetadata(),
236 'detectorName': self._detectorName,
237 'detectorSerial': self._detectorSerial,
238 'detectorId': self._detectorId,
239 'hasTable': self.tableData is not None,
240 'amplifiers': dict(),
241 }
242 for ampName in self.linearityType:
243 outDict['amplifiers'][ampName] = {'linearityType': self.linearityType[ampName],
244 'linearityCoeffs': self.linearityCoeffs[ampName].tolist(),
245 'linearityBBox': self.linearityBBox[ampName],
246 'fitParams': self.fitParams[ampName].tolist(),
247 'fitParamsErr': self.fitParamsErr[ampName].tolist(),
248 'fitChiSq': self.fitChiSq[ampName]}
249 if self.tableData is not None:
250 outDict['tableData'] = self.tableData.tolist()
252 return outDict
254 @classmethod
255 def fromTable(cls, tableList):
256 """Read linearity from a FITS file.
258 This method uses the `fromDict` method to create the
259 calibration, after constructing an appropriate dictionary from
260 the input tables.
262 Parameters
263 ----------
264 tableList : `list` [`astropy.table.Table`]
265 afwTable read from input file name.
267 Returns
268 -------
269 linearity : `~lsst.ip.isr.linearize.Linearizer``
270 Linearity parameters.
272 Notes
273 -----
274 The method reads a FITS file with 1 or 2 extensions. The metadata is read from the header of
275 extension 1, which must exist. Then the table is loaded, and the ['AMPLIFIER_NAME', 'TYPE',
276 'COEFFS', 'BBOX_X0', 'BBOX_Y0', 'BBOX_DX', 'BBOX_DY'] columns are read and used to
277 set each dictionary by looping over rows.
278 Eextension 2 is then attempted to read in the try block (which only exists for lookup tables).
279 It has a column named 'LOOKUP_VALUES' that contains a vector of the lookup entries in each row.
281 """
282 coeffTable = tableList[0]
284 metadata = coeffTable.meta
285 inDict = dict()
286 inDict['metadata'] = metadata
287 inDict['hasLinearity'] = metadata.get('HAS_LINEARITY', False)
288 inDict['amplifiers'] = dict()
290 for record in coeffTable:
291 ampName = record['AMPLIFIER_NAME']
293 fitParams = record['FIT_PARAMS'] if 'FIT_PARAMS' in record.columns else np.array([0.0])
294 fitParamsErr = record['FIT_PARAMS_ERR'] if 'FIT_PARAMS_ERR' in record.columns else np.array([0.0])
295 fitChiSq = record['RED_CHI_SQ'] if 'RED_CHI_SQ' in record.columns else np.nan
297 inDict['amplifiers'][ampName] = {
298 'linearityType': record['TYPE'],
299 'linearityCoeffs': record['COEFFS'],
300 'linearityBBox': Box2I(Point2I(record['BBOX_X0'], record['BBOX_Y0']),
301 Extent2I(record['BBOX_DX'], record['BBOX_DY'])),
302 'fitParams': fitParams,
303 'fitParamsErr': fitParamsErr,
304 'fitChiSq': fitChiSq,
305 }
307 if len(tableList) > 1:
308 tableData = tableList[1]
309 inDict['tableData'] = [record['LOOKUP_VALUES'] for record in tableData]
311 return cls().fromDict(inDict)
313 def toTable(self):
314 """Construct a list of tables containing the information in this calibration
316 The list of tables should create an identical calibration
317 after being passed to this class's fromTable method.
319 Returns
320 -------
321 tableList : `list` [`astropy.table.Table`]
322 List of tables containing the linearity calibration
323 information.
324 """
326 tableList = []
327 self.updateMetadata()
328 catalog = Table([{'AMPLIFIER_NAME': ampName,
329 'TYPE': self.linearityType[ampName],
330 'COEFFS': self.linearityCoeffs[ampName],
331 'BBOX_X0': self.linearityBBox[ampName].getMinX(),
332 'BBOX_Y0': self.linearityBBox[ampName].getMinY(),
333 'BBOX_DX': self.linearityBBox[ampName].getWidth(),
334 'BBOX_DY': self.linearityBBox[ampName].getHeight(),
335 'FIT_PARAMS': self.fitParams[ampName],
336 'FIT_PARAMS_ERR': self.fitParamsErr[ampName],
337 'RED_CHI_SQ': self.fitChiSq[ampName],
338 } for ampName in self.ampNames])
339 catalog.meta = self.getMetadata().toDict()
340 tableList.append(catalog)
342 if self.tableData is not None:
343 catalog = Table([{'LOOKUP_VALUES': value} for value in self.tableData])
344 tableList.append(catalog)
345 return(tableList)
347 def getLinearityTypeByName(self, linearityTypeName):
348 """Determine the linearity class to use from the type name.
350 Parameters
351 ----------
352 linearityTypeName : str
353 String name of the linearity type that is needed.
355 Returns
356 -------
357 linearityType : `~lsst.ip.isr.linearize.LinearizeBase`
358 The appropriate linearity class to use. If no matching class
359 is found, `None` is returned.
360 """
361 for t in [LinearizeLookupTable,
362 LinearizeSquared,
363 LinearizePolynomial,
364 LinearizeProportional,
365 LinearizeSpline,
366 LinearizeNone]:
367 if t.LinearityType == linearityTypeName:
368 return t
369 return None
371 def validate(self, detector=None, amplifier=None):
372 """Validate linearity for a detector/amplifier.
374 Parameters
375 ----------
376 detector : `lsst.afw.cameraGeom.Detector`, optional
377 Detector to validate, along with its amplifiers.
378 amplifier : `lsst.afw.cameraGeom.Amplifier`, optional
379 Single amplifier to validate.
381 Raises
382 ------
383 RuntimeError :
384 Raised if there is a mismatch in linearity parameters, and
385 the cameraGeom parameters are not being overridden.
386 """
387 amplifiersToCheck = []
388 if detector:
389 if self._detectorName != detector.getName():
390 raise RuntimeError("Detector names don't match: %s != %s" %
391 (self._detectorName, detector.getName()))
392 if int(self._detectorId) != int(detector.getId()):
393 raise RuntimeError("Detector IDs don't match: %s != %s" %
394 (int(self._detectorId), int(detector.getId())))
395 if self._detectorSerial != detector.getSerial():
396 raise RuntimeError("Detector serial numbers don't match: %s != %s" %
397 (self._detectorSerial, detector.getSerial()))
398 if len(detector.getAmplifiers()) != len(self.linearityCoeffs.keys()):
399 raise RuntimeError("Detector number of amps = %s does not match saved value %s" %
400 (len(detector.getAmplifiers()),
401 len(self.linearityCoeffs.keys())))
402 amplifiersToCheck.extend(detector.getAmplifiers())
404 if amplifier:
405 amplifiersToCheck.extend(amplifier)
407 for amp in amplifiersToCheck:
408 ampName = amp.getName()
409 if ampName not in self.linearityCoeffs.keys():
410 raise RuntimeError("Amplifier %s is not in linearity data" %
411 (ampName, ))
412 if amp.getLinearityType() != self.linearityType[ampName]:
413 if self.override:
414 self.log.warning("Overriding amplifier defined linearityType (%s) for %s",
415 self.linearityType[ampName], ampName)
416 else:
417 raise RuntimeError("Amplifier %s type %s does not match saved value %s" %
418 (ampName, amp.getLinearityType(), self.linearityType[ampName]))
419 if (amp.getLinearityCoeffs().shape != self.linearityCoeffs[ampName].shape or not
420 np.allclose(amp.getLinearityCoeffs(), self.linearityCoeffs[ampName], equal_nan=True)):
421 if self.override:
422 self.log.warning("Overriding amplifier defined linearityCoeffs (%s) for %s",
423 self.linearityCoeffs[ampName], ampName)
424 else:
425 raise RuntimeError("Amplifier %s coeffs %s does not match saved value %s" %
426 (ampName, amp.getLinearityCoeffs(), self.linearityCoeffs[ampName]))
428 def applyLinearity(self, image, detector=None, log=None):
429 """Apply the linearity to an image.
431 If the linearity parameters are populated, use those,
432 otherwise use the values from the detector.
434 Parameters
435 ----------
436 image : `~lsst.afw.image.image`
437 Image to correct.
438 detector : `~lsst.afw.cameraGeom.detector`
439 Detector to use for linearity parameters if not already
440 populated.
441 log : `~logging.Logger`, optional
442 Log object to use for logging.
443 """
444 if log is None:
445 log = self.log
446 if detector and not self.hasLinearity:
447 self.fromDetector(detector)
449 self.validate(detector)
451 numAmps = 0
452 numLinearized = 0
453 numOutOfRange = 0
454 for ampName in self.linearityType.keys():
455 linearizer = self.getLinearityTypeByName(self.linearityType[ampName])
456 numAmps += 1
457 if linearizer is not None:
458 ampView = image.Factory(image, self.linearityBBox[ampName])
459 success, outOfRange = linearizer()(ampView, **{'coeffs': self.linearityCoeffs[ampName],
460 'table': self.tableData,
461 'log': self.log})
462 numOutOfRange += outOfRange
463 if success:
464 numLinearized += 1
465 elif log is not None:
466 log.warning("Amplifier %s did not linearize.",
467 ampName)
468 return Struct(
469 numAmps=numAmps,
470 numLinearized=numLinearized,
471 numOutOfRange=numOutOfRange
472 )
475class LinearizeBase(metaclass=abc.ABCMeta):
476 """Abstract base class functor for correcting non-linearity.
478 Subclasses must define __call__ and set class variable
479 LinearityType to a string that will be used for linearity type in
480 the cameraGeom.Amplifier.linearityType field.
482 All linearity corrections should be defined in terms of an
483 additive correction, such that:
485 corrected_value = uncorrected_value + f(uncorrected_value)
486 """
487 LinearityType = None # linearity type, a string used for AmpInfoCatalogs
489 @abc.abstractmethod
490 def __call__(self, image, **kwargs):
491 """Correct non-linearity.
493 Parameters
494 ----------
495 image : `lsst.afw.image.Image`
496 Image to be corrected
497 kwargs : `dict`
498 Dictionary of parameter keywords:
499 ``"coeffs"``
500 Coefficient vector (`list` or `numpy.array`).
501 ``"table"``
502 Lookup table data (`numpy.array`).
503 ``"log"``
504 Logger to handle messages (`logging.Logger`).
506 Returns
507 -------
508 output : `bool`
509 If true, a correction was applied successfully.
511 Raises
512 ------
513 RuntimeError:
514 Raised if the linearity type listed in the
515 detector does not match the class type.
516 """
517 pass
520class LinearizeLookupTable(LinearizeBase):
521 """Correct non-linearity with a persisted lookup table.
523 The lookup table consists of entries such that given
524 "coefficients" c0, c1:
526 for each i,j of image:
527 rowInd = int(c0)
528 colInd = int(c1 + uncorrImage[i,j])
529 corrImage[i,j] = uncorrImage[i,j] + table[rowInd, colInd]
531 - c0: row index; used to identify which row of the table to use
532 (typically one per amplifier, though one can have multiple
533 amplifiers use the same table)
534 - c1: column index offset; added to the uncorrected image value
535 before truncation; this supports tables that can handle
536 negative image values; also, if the c1 ends with .5 then
537 the nearest index is used instead of truncating to the
538 next smaller index
539 """
540 LinearityType = "LookupTable"
542 def __call__(self, image, **kwargs):
543 """Correct for non-linearity.
545 Parameters
546 ----------
547 image : `lsst.afw.image.Image`
548 Image to be corrected
549 kwargs : `dict`
550 Dictionary of parameter keywords:
551 ``"coeffs"``
552 Columnation vector (`list` or `numpy.array`).
553 ``"table"``
554 Lookup table data (`numpy.array`).
555 ``"log"``
556 Logger to handle messages (`logging.Logger`).
558 Returns
559 -------
560 output : `tuple` [`bool`, `int`]
561 If true, a correction was applied successfully. The
562 integer indicates the number of pixels that were
563 uncorrectable by being out of range.
565 Raises
566 ------
567 RuntimeError:
568 Raised if the requested row index is out of the table
569 bounds.
570 """
571 numOutOfRange = 0
573 rowInd, colIndOffset = kwargs['coeffs'][0:2]
574 table = kwargs['table']
575 log = kwargs['log']
577 numTableRows = table.shape[0]
578 rowInd = int(rowInd)
579 if rowInd < 0 or rowInd > numTableRows:
580 raise RuntimeError("LinearizeLookupTable rowInd=%s not in range[0, %s)" %
581 (rowInd, numTableRows))
582 tableRow = np.array(table[rowInd, :], dtype=image.getArray().dtype)
584 numOutOfRange += applyLookupTable(image, tableRow, colIndOffset)
586 if numOutOfRange > 0 and log is not None:
587 log.warning("%s pixels were out of range of the linearization table",
588 numOutOfRange)
589 if numOutOfRange < image.getArray().size:
590 return True, numOutOfRange
591 else:
592 return False, numOutOfRange
595class LinearizePolynomial(LinearizeBase):
596 """Correct non-linearity with a polynomial mode.
598 corrImage = uncorrImage + sum_i c_i uncorrImage^(2 + i)
600 where c_i are the linearity coefficients for each amplifier.
601 Lower order coefficients are not included as they duplicate other
602 calibration parameters:
603 ``"k0"``
604 A coefficient multiplied by uncorrImage**0 is equivalent to
605 bias level. Irrelevant for correcting non-linearity.
606 ``"k1"``
607 A coefficient multiplied by uncorrImage**1 is proportional
608 to the gain. Not necessary for correcting non-linearity.
609 """
610 LinearityType = "Polynomial"
612 def __call__(self, image, **kwargs):
613 """Correct non-linearity.
615 Parameters
616 ----------
617 image : `lsst.afw.image.Image`
618 Image to be corrected
619 kwargs : `dict`
620 Dictionary of parameter keywords:
621 ``"coeffs"``
622 Coefficient vector (`list` or `numpy.array`).
623 If the order of the polynomial is n, this list
624 should have a length of n-1 ("k0" and "k1" are
625 not needed for the correction).
626 ``"log"``
627 Logger to handle messages (`logging.Logger`).
629 Returns
630 -------
631 output : `tuple` [`bool`, `int`]
632 If true, a correction was applied successfully. The
633 integer indicates the number of pixels that were
634 uncorrectable by being out of range.
635 """
636 if not np.any(np.isfinite(kwargs['coeffs'])):
637 return False, 0
638 if not np.any(kwargs['coeffs']):
639 return False, 0
641 ampArray = image.getArray()
642 correction = np.zeros_like(ampArray)
643 for order, coeff in enumerate(kwargs['coeffs'], start=2):
644 correction += coeff * np.power(ampArray, order)
645 ampArray += correction
647 return True, 0
650class LinearizeSquared(LinearizeBase):
651 """Correct non-linearity with a squared model.
653 corrImage = uncorrImage + c0*uncorrImage^2
655 where c0 is linearity coefficient 0 for each amplifier.
656 """
657 LinearityType = "Squared"
659 def __call__(self, image, **kwargs):
660 """Correct for non-linearity.
662 Parameters
663 ----------
664 image : `lsst.afw.image.Image`
665 Image to be corrected
666 kwargs : `dict`
667 Dictionary of parameter keywords:
668 ``"coeffs"``
669 Coefficient vector (`list` or `numpy.array`).
670 ``"log"``
671 Logger to handle messages (`logging.Logger`).
673 Returns
674 -------
675 output : `tuple` [`bool`, `int`]
676 If true, a correction was applied successfully. The
677 integer indicates the number of pixels that were
678 uncorrectable by being out of range.
679 """
681 sqCoeff = kwargs['coeffs'][0]
682 if sqCoeff != 0:
683 ampArr = image.getArray()
684 ampArr *= (1 + sqCoeff*ampArr)
685 return True, 0
686 else:
687 return False, 0
690class LinearizeSpline(LinearizeBase):
691 """Correct non-linearity with a spline model.
693 corrImage = uncorrImage - Spline(coeffs, uncorrImage)
695 Notes
696 -----
698 The spline fit calculates a correction as a function of the
699 expected linear flux term. Because of this, the correction needs
700 to be subtracted from the observed flux.
702 """
703 LinearityType = "Spline"
705 def __call__(self, image, **kwargs):
706 """Correct for non-linearity.
708 Parameters
709 ----------
710 image : `lsst.afw.image.Image`
711 Image to be corrected
712 kwargs : `dict`
713 Dictionary of parameter keywords:
714 ``"coeffs"``
715 Coefficient vector (`list` or `numpy.array`).
716 ``"log"``
717 Logger to handle messages (`logging.Logger`).
719 Returns
720 -------
721 output : `tuple` [`bool`, `int`]
722 If true, a correction was applied successfully. The
723 integer indicates the number of pixels that were
724 uncorrectable by being out of range.
725 """
726 splineCoeff = kwargs['coeffs']
727 centers, values = np.split(splineCoeff, 2)
728 interp = afwMath.makeInterpolate(centers.tolist(), values.tolist(),
729 afwMath.stringToInterpStyle("AKIMA_SPLINE"))
731 ampArr = image.getArray()
732 delta = interp.interpolate(ampArr.flatten())
733 ampArr -= np.array(delta).reshape(ampArr.shape)
735 return True, 0
738class LinearizeProportional(LinearizeBase):
739 """Do not correct non-linearity.
740 """
741 LinearityType = "Proportional"
743 def __call__(self, image, **kwargs):
744 """Do not correct for non-linearity.
746 Parameters
747 ----------
748 image : `lsst.afw.image.Image`
749 Image to be corrected
750 kwargs : `dict`
751 Dictionary of parameter keywords:
752 ``"coeffs"``
753 Coefficient vector (`list` or `numpy.array`).
754 ``"log"``
755 Logger to handle messages (`logging.Logger`).
757 Returns
758 -------
759 output : `tuple` [`bool`, `int`]
760 If true, a correction was applied successfully. The
761 integer indicates the number of pixels that were
762 uncorrectable by being out of range.
763 """
764 return True, 0
767class LinearizeNone(LinearizeBase):
768 """Do not correct non-linearity.
769 """
770 LinearityType = "None"
772 def __call__(self, image, **kwargs):
773 """Do not correct for non-linearity.
775 Parameters
776 ----------
777 image : `lsst.afw.image.Image`
778 Image to be corrected
779 kwargs : `dict`
780 Dictionary of parameter keywords:
781 ``"coeffs"``
782 Coefficient vector (`list` or `numpy.array`).
783 ``"log"``
784 Logger to handle messages (`logging.Logger`).
786 Returns
787 -------
788 output : `tuple` [`bool`, `int`]
789 If true, a correction was applied successfully. The
790 integer indicates the number of pixels that were
791 uncorrectable by being out of range.
792 """
793 return True, 0