Coverage for python/lsst/images/tests/_checks.py: 10%

1# This file is part of lsst-images. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# Use of this source code is governed by a 3-clause BSD-style 

10# license that can be found in the LICENSE file. 

11 

12from __future__ import annotations 

13 

14__all__ = ( 

15 "arrays_to_legacy_points", 

16 "assert_close", 

17 "assert_equal_allow_nan", 

18 "assert_images_equal", 

19 "assert_masked_images_equal", 

20 "assert_masks_equal", 

21 "assert_projections_equal", 

22 "assert_psfs_equal", 

23 "check_astropy_wcs_interface", 

24 "check_projection", 

25 "check_transform", 

26 "compare_amplifier_to_legacy", 

27 "compare_aperture_corrections_to_legacy", 

28 "compare_cell_coadd_to_legacy", 

29 "compare_detector_to_legacy", 

30 "compare_field_to_legacy", 

31 "compare_image_to_legacy", 

32 "compare_mask_to_legacy", 

33 "compare_masked_image_to_legacy", 

34 "compare_observation_summary_stats_to_legacy", 

35 "compare_photo_calib_to_legacy", 

36 "compare_projection_to_legacy_wcs", 

37 "compare_psf_to_legacy", 

38 "compare_visit_image_to_legacy", 

39 "legacy_coords_to_astropy", 

40 "legacy_points_to_xy_array", 

41) 

42 

43import dataclasses 

44import math 

45import unittest 

46from collections.abc import Mapping 

47from typing import TYPE_CHECKING, Any, Literal, cast 

48 

49import astropy.units as u 

50import astropy.wcs.wcsapi 

51import numpy as np 

52from astropy.coordinates import SkyCoord 

53 

54from .._geom import XY, YX, BoundsError, Box 

55from .._image import Image 

56from .._mask import Mask, MaskPlane 

57from .._masked_image import MaskedImage 

58from .._observation_summary_stats import ObservationSummaryStats 

59from .._transforms import DetectorFrame, Frame, Projection, SkyFrame, TractFrame, Transform 

60from .._visit_image import VisitImage 

61from ..aperture_corrections import ApertureCorrectionMap 

62from ..cameras import Amplifier, Detector, DetectorType, ReadoutCorner 

63from ..cells import CellCoadd, CellIJ, CoaddProvenance 

64from ..fields import BaseField, ChebyshevField 

65from ..psfs import PointSpreadFunction 

66 

67if TYPE_CHECKING: 

68 try: 

69 from lsst.cell_coadds import MultipleCellCoadd 

70 except ImportError: 

71 type MultipleCellCoadd = Any # type: ignore[no-redef] 

72 try: 

73 from lsst.afw.image import PhotoCalib as LegacyPhotoCalib 

74 except ImportError: 

75 type LegacyPhotoCalib = Any # type: ignore[no-redef] 

76 

77 

78def assert_close( 

79 tc: unittest.TestCase, 

80 a: np.ndarray | u.Quantity | float, 

81 b: np.ndarray | u.Quantity | float, 

82 **kwargs: Any, 

83) -> None: 

84 """Test that two arrays, floats, or quantities are almost equal. 

85 

86 Parameters 

87 ---------- 

88 tc 

89 Test case object with assert methods to use. 

90 a 

91 Array, float, or quantity to compare. 

92 b 

93 Array, float, or quantity to compare. 

94 **kwargs 

95 Forwarded to `astropy.units.allclose`. 

96 """ 

97 tc.assertTrue(u.allclose(a, b, **kwargs), msg=f"{a} != {b}") 

98 

99 

100def assert_equal_allow_nan(tc: unittest.TestCase, a: float, b: float) -> None: 

101 """Test that two floating point values are equal, with nan == nan.""" 

102 try: 

103 tc.assertEqual(a, b) 

104 except AssertionError: 

105 if not (math.isnan(a) and math.isnan(b)): 

106 raise 

107 

108 

109def assert_images_equal( 

110 tc: unittest.TestCase, 

111 a: Image, 

112 b: Image, 

113 *, 

114 rtol: float = 0.0, 

115 atol: float = 0.0, 

116 expect_view: bool | Literal["array"] | None = None, 

117) -> None: 

118 """Assert that two images are equal or nearly equal.""" 

119 tc.assertEqual(a.bbox, b.bbox) 

120 tc.assertEqual(a.unit, b.unit) 

121 assert_projections_equal(tc, a.projection, b.projection) 

122 if expect_view is not None: 

123 tc.assertEqual(np.may_share_memory(a.array, b.array), bool(expect_view)) 

124 if expect_view == "array": 

125 tc.assertEqual(a.metadata, b.metadata) 

126 else: 

127 tc.assertEqual(a.metadata is b.metadata, expect_view) 

128 if not expect_view: 

129 assert_close(tc, a.array, b.array, atol=atol, rtol=rtol) 

130 tc.assertEqual(a.metadata, b.metadata) 

131 

132 

133def assert_masks_equal(tc: unittest.TestCase, a: Mask, b: Mask) -> None: 

134 """Assert that two masks are equal or nearly equal.""" 

135 tc.assertEqual(a.bbox, b.bbox) 

136 tc.assertEqual(a.schema, b.schema) 

137 tc.assertEqual(a.metadata, b.metadata) 

138 assert_projections_equal(tc, a.projection, b.projection) 

139 np.testing.assert_array_equal(a.array, b.array) 

140 

141 

142def assert_masked_images_equal( 

143 tc: unittest.TestCase, 

144 a: MaskedImage, 

145 b: MaskedImage, 

146 *, 

147 rtol: float = 0.0, 

148 atol: float = 0.0, 

149 expect_view: bool | None = None, 

150) -> None: 

151 """Assert that two masked images are equal or nearly equal.""" 

152 tc.assertEqual(a.metadata, b.metadata) 

153 assert_projections_equal(tc, a.projection, b.projection) 

154 assert_images_equal(tc, a.image, b.image, rtol=rtol, atol=atol, expect_view=expect_view) 

155 assert_masks_equal(tc, a.mask, b.mask) 

156 assert_images_equal(tc, a.variance, b.variance, rtol=rtol, atol=atol, expect_view=expect_view) 

157 

158 

159def assert_psfs_equal( 

160 tc: unittest.TestCase, 

161 psf1: PointSpreadFunction, 

162 psf2: PointSpreadFunction, 

163 points: YX[np.ndarray] | XY[np.ndarray] | None = None, 

164) -> int: 

165 """Compare two PSF objets. 

166 

167 Parameters 

168 ---------- 

169 tc 

170 Test case object with assert methods to use. 

171 psf1 

172 Point-spread function to test. 

173 psf2 

174 The other point-spread function to test. 

175 points 

176 Points to evaluate the PSFs at. If not provided, the intersection of 

177 the PSF bounding boxes are used to generate points on a grid. 

178 

179 Returns 

180 ------- 

181 `int` 

182 The number of points actually tested. 

183 """ 

184 if points is None: 

185 points = psf1.bounds.bbox.intersection(psf1.bounds.bbox).meshgrid(3).map(np.ravel) 

186 

187 tc.assertEqual(psf1.kernel_bbox, psf2.kernel_bbox) 

188 

189 n_points_tested: int = 0 

190 for x, y in zip(points.x, points.y): 

191 if not psf1.bounds.contains(x=x, y=y): 

192 with tc.assertRaises(BoundsError): 

193 psf2.compute_kernel_image(x=x, y=y) 

194 continue 

195 tc.assertEqual(psf1.compute_kernel_image(x=x, y=y), psf2.compute_kernel_image(x=x, y=y)) 

196 tc.assertEqual(psf1.compute_stellar_bbox(x=x, y=y), psf2.compute_stellar_bbox(x=x, y=y)) 

197 tc.assertEqual(psf1.compute_stellar_image(x=x, y=y), psf2.compute_stellar_image(x=x, y=y)) 

198 n_points_tested += 1 

199 return n_points_tested 

200 

201 

202def compare_image_to_legacy( 

203 tc: unittest.TestCase, image: Image, legacy_image: Any, expect_view: bool | None = None 

204) -> None: 

205 """Compare an `.Image` object to a legacy `lsst.afw.image.Image` object.""" 

206 tc.assertEqual(image.bbox, Box.from_legacy(legacy_image.getBBox())) 

207 if expect_view is not None: 

208 tc.assertEqual(np.may_share_memory(image.array, legacy_image.array), expect_view) 

209 if not expect_view: 

210 np.testing.assert_array_equal(image.array, legacy_image.array) 

211 

212 

213def compare_mask_to_legacy( 

214 tc: unittest.TestCase, mask: Mask, legacy_mask: Any, plane_map: Mapping[str, MaskPlane] | None = None 

215) -> None: 

216 """Compare a `.Mask` object to a legacy `lsst.afw.image.Mask` object.""" 

217 tc.assertEqual(mask.bbox, Box.from_legacy(legacy_mask.getBBox())) 

218 if plane_map is None: 

219 plane_map = {plane.name: plane for plane in mask.schema if plane is not None} 

220 for old_name, new_plane in plane_map.items(): 

221 np.testing.assert_array_equal( 

222 (legacy_mask.array & legacy_mask.getPlaneBitMask(old_name)).astype(bool), 

223 mask.get(new_plane.name), 

224 ) 

225 

226 

227def compare_masked_image_to_legacy( 

228 tc: unittest.TestCase, 

229 masked_image: MaskedImage, 

230 legacy_masked_image: Any, 

231 *, 

232 plane_map: Mapping[str, MaskPlane] | None = None, 

233 expect_view: bool | None = None, 

234 alternates: Mapping[str, Any] | None = None, 

235) -> None: 

236 """Compare a `.MaskedImage` object to a legacy `lsst.afw.image.MaskedImage` 

237 object. 

238 

239 Parameters 

240 ---------- 

241 tc 

242 Test case to use for asserts. 

243 masked_image 

244 New image to test. 

245 legacy_masked_image 

246 Legacy image to test against. 

247 plane_map 

248 Mapping between new and legacy mask planes. 

249 expect_view 

250 Whether to test that the image and variance arrays do or do not share 

251 memory. 

252 alternates 

253 A mapping of other versions of one or more (new) components to also 

254 check against the legacy versions of those components. 

255 """ 

256 compare_image_to_legacy(tc, masked_image.image, legacy_masked_image.getImage(), expect_view=expect_view) 

257 compare_mask_to_legacy(tc, masked_image.mask, legacy_masked_image.getMask(), plane_map=plane_map) 

258 compare_image_to_legacy( 

259 tc, masked_image.variance, legacy_masked_image.getVariance(), expect_view=expect_view 

260 ) 

261 if alternates: 

262 if image := alternates.get("image"): 

263 compare_image_to_legacy(tc, image, legacy_masked_image.getImage(), expect_view=expect_view) 

264 if mask := alternates.get("mask"): 

265 compare_mask_to_legacy(tc, mask, legacy_masked_image.getMask(), plane_map=plane_map) 

266 if variance := alternates.get("variance"): 

267 compare_image_to_legacy(tc, variance, legacy_masked_image.getVariance(), expect_view=expect_view) 

268 

269 

270def compare_visit_image_to_legacy( 

271 tc: unittest.TestCase, 

272 visit_image: VisitImage, 

273 legacy_exposure: Any, 

274 *, 

275 plane_map: Mapping[str, MaskPlane] | None = None, 

276 expect_view: bool | None = None, 

277 instrument: str, 

278 visit: int, 

279 detector: int, 

280 applied_legacy_photo_calib: LegacyPhotoCalib | None = None, 

281 alternates: Mapping[str, Any] | None = None, 

282) -> None: 

283 """Compare a `.VisitImage` object to a legacy `lsst.afw.image.Exposure` 

284 object. 

285 

286 Parameters 

287 ---------- 

288 tc 

289 Test case to use for asserts. 

290 visit_image 

291 New image to test. 

292 legacy_exposure 

293 Legacy image to test against. 

294 plane_map 

295 Mapping between new and legacy mask planes. 

296 expect_view 

297 Whether to test that the image and variance arrays do or do not share 

298 memory. 

299 instrument 

300 Expected instrument name. 

301 visit 

302 Expected visit ID. 

303 detector 

304 Expected detector ID. 

305 alternates 

306 A mapping of other versions of one or more (new) components to also 

307 check against the legacy versions of those components. 

308 """ 

309 compare_masked_image_to_legacy( 

310 tc, 

311 visit_image, 

312 legacy_exposure.getMaskedImage(), 

313 plane_map=plane_map, 

314 expect_view=expect_view, 

315 alternates=alternates, 

316 ) 

317 detector_bbox = Box.from_legacy(legacy_exposure.getDetector().getBBox()) 

318 compare_projection_to_legacy_wcs( 

319 tc, 

320 visit_image.projection, 

321 legacy_exposure.getWcs(), 

322 DetectorFrame(instrument=instrument, visit=visit, detector=detector, bbox=detector_bbox), 

323 visit_image.bbox, 

324 ) 

325 tc.assertIs(visit_image.projection, visit_image.mask.projection) 

326 tc.assertIs(visit_image.projection, visit_image.variance.projection) 

327 compare_psf_to_legacy(tc, visit_image.psf, legacy_exposure.getPsf()) 

328 compare_observation_summary_stats_to_legacy( 

329 tc, visit_image.summary_stats, legacy_exposure.info.getSummaryStats() 

330 ) 

331 compare_detector_to_legacy(tc, visit_image.detector, legacy_exposure.getDetector(), is_raw_assembled=True) 

332 # Make a tiny box for Field comparisons that need to make arrays; that can 

333 # get expensive otherwisre. 

334 tiny_bbox = detector_bbox.local[2:4, 3:6] 

335 compare_aperture_corrections_to_legacy( 

336 tc, visit_image.aperture_corrections, legacy_exposure.info.getApCorrMap(), tiny_bbox 

337 ) 

338 compare_photo_calib_to_legacy( 

339 tc, 

340 visit_image.photometric_scaling, 

341 legacy_exposure.info.getPhotoCalib(), 

342 applied_legacy_photo_calib=applied_legacy_photo_calib, 

343 subimage_bbox=tiny_bbox, 

344 ) 

345 if alternates: 

346 if (bbox := alternates.get("bbox")) is not None: 

347 tc.assertEqual(bbox, visit_image.bbox) 

348 if projection := alternates.get("projection"): 

349 compare_projection_to_legacy_wcs( 

350 tc, 

351 projection, 

352 legacy_exposure.getWcs(), 

353 DetectorFrame(instrument=instrument, visit=visit, detector=detector, bbox=detector_bbox), 

354 visit_image.bbox, 

355 ) 

356 if psf := alternates.get("psf"): 

357 compare_psf_to_legacy(tc, psf, legacy_exposure.getPsf()) 

358 if summary_stats := alternates.get("summary_stats"): 

359 compare_observation_summary_stats_to_legacy( 

360 tc, summary_stats, legacy_exposure.info.getSummaryStats() 

361 ) 

362 if detector_obj := alternates.get("detector"): 

363 compare_detector_to_legacy(tc, detector_obj, legacy_exposure.getDetector(), is_raw_assembled=True) 

364 if obs_info := alternates.get("obs_info"): 

365 visitInfo = legacy_exposure.visitInfo 

366 tc.assertEqual(obs_info.instrument, visitInfo.getInstrumentLabel()) 

367 if aperture_corrections := alternates.get("aperture_corrections"): 

368 compare_aperture_corrections_to_legacy( 

369 tc, aperture_corrections, legacy_exposure.info.getApCorrMap(), tiny_bbox 

370 ) 

371 if (photometric_scaling := alternates.get("photometic_scaling", ...)) is not ...: 

372 compare_photo_calib_to_legacy( 

373 tc, 

374 photometric_scaling, 

375 legacy_exposure.info.getPhotoCalib(), 

376 applied_legacy_photo_calib=applied_legacy_photo_calib, 

377 subimage_bbox=tiny_bbox, 

378 ) 

379 

380 

381def compare_photo_calib_to_legacy( 

382 tc: unittest.TestCase, 

383 photometric_scaling: BaseField | None, 

384 legacy_photo_calib: LegacyPhotoCalib, 

385 *, 

386 applied_legacy_photo_calib: LegacyPhotoCalib | None = None, 

387 subimage_bbox: Box, 

388) -> None: 

389 if legacy_photo_calib._isConstant: 

390 if legacy_photo_calib.getCalibrationMean() == 1.0: 

391 if applied_legacy_photo_calib is None: 

392 tc.assertIsNone(photometric_scaling) 

393 return 

394 else: 

395 legacy_photo_calib = applied_legacy_photo_calib 

396 if legacy_photo_calib._isConstant: 

397 assert isinstance(photometric_scaling, ChebyshevField) 

398 assert_close( 

399 tc, photometric_scaling.coefficients, np.array([[legacy_photo_calib.getCalibrationMean()]]) 

400 ) 

401 else: 

402 assert photometric_scaling is not None 

403 compare_field_to_legacy( 

404 tc, 

405 photometric_scaling / legacy_photo_calib.getCalibrationMean(), 

406 legacy_photo_calib.computeScaledCalibration(), 

407 subimage_bbox, 

408 ) 

409 

410 

411def compare_cell_coadd_to_legacy( 

412 tc: unittest.TestCase, 

413 cell_coadd: CellCoadd, 

414 legacy_cell_coadd: MultipleCellCoadd, 

415 *, 

416 tract_bbox: Box, 

417 plane_map: Mapping[str, MaskPlane] | None = None, 

418 alternates: Mapping[str, Any] | None = None, 

419 psf_points: XY[np.ndarray] | YX[np.ndarray] | None = None, 

420) -> None: 

421 """Compare a `.cells.CellCoadd` object to a legacy 

422 `lsst.cell_coadds.MultipleCellCoadd` object. 

423 

424 Parameters 

425 ---------- 

426 tc 

427 Test case to use for asserts. 

428 cell_coadd 

429 New coadd to test. 

430 legacy_cell_coadd 

431 Legacy coadd to test against. 

432 tract_bbox 

433 Bounding box of the full tract. 

434 psf_points 

435 Points to use to compare the PSFs. 

436 plane_map 

437 Mapping between new and legacy mask planes. 

438 alternates 

439 A mapping of other versions of one or more (new) components to also 

440 check against the legacy versions of those components. 

441 """ 

442 legacy_stitched = legacy_cell_coadd.stitch(cell_coadd.bbox.to_legacy()) 

443 compare_image_to_legacy(tc, cell_coadd.image, legacy_stitched.image, expect_view=False) 

444 compare_mask_to_legacy(tc, cell_coadd.mask, legacy_stitched.mask, plane_map=plane_map) 

445 compare_image_to_legacy(tc, cell_coadd.variance, legacy_stitched.variance, expect_view=False) 

446 if legacy_stitched.mask_fractions is not None: 

447 compare_image_to_legacy( 

448 tc, cell_coadd.mask_fractions["rejected"], legacy_stitched.mask_fractions, expect_view=False 

449 ) 

450 for n in range(legacy_stitched.n_noise_realizations): 

451 compare_image_to_legacy( 

452 tc, cell_coadd.noise_realizations[n], legacy_stitched.noise_realizations[n], expect_view=False 

453 ) 

454 tc.assertEqual(cell_coadd.skymap, legacy_stitched.identifiers.skymap) 

455 tc.assertEqual(cell_coadd.tract, legacy_stitched.identifiers.tract) 

456 tc.assertEqual(cell_coadd.patch.index.x, legacy_stitched.identifiers.patch.x) 

457 tc.assertEqual(cell_coadd.patch.index.y, legacy_stitched.identifiers.patch.y) 

458 tc.assertEqual(cell_coadd.band, legacy_stitched.identifiers.band) 

459 tc.assertTrue(tract_bbox.contains(cell_coadd.patch.outer_bbox)) 

460 tc.assertTrue(cell_coadd.patch.outer_bbox.contains(cell_coadd.patch.inner_bbox)) 

461 tc.assertTrue(cell_coadd.patch.outer_bbox.contains(cell_coadd.bbox)) 

462 tc.assertEqual(cell_coadd.unit, u.Unit(legacy_cell_coadd.common.units.value)) 

463 tc.assertTrue(cell_coadd.bounds.bbox.contains(cell_coadd.bbox)) 

464 tc.assertTrue(cell_coadd.grid.bbox.contains(cell_coadd.bbox)) 

465 compare_projection_to_legacy_wcs( 

466 tc, 

467 cell_coadd.projection, 

468 legacy_cell_coadd.wcs, 

469 TractFrame( 

470 skymap=legacy_cell_coadd.identifiers.skymap, 

471 tract=legacy_cell_coadd.identifiers.tract, 

472 bbox=tract_bbox, 

473 ), 

474 cell_coadd.bbox, 

475 is_fits=True, 

476 ) 

477 tc.assertIs(cell_coadd.projection, cell_coadd.mask.projection) 

478 tc.assertIs(cell_coadd.projection, cell_coadd.variance.projection) 

479 compare_psf_to_legacy( 

480 tc, cell_coadd.psf, legacy_stitched.psf, expect_legacy_raise_on_out_of_bounds=True, points=psf_points 

481 ) 

482 compare_cell_coadd_provenance_to_legacy(tc, cell_coadd.provenance, legacy_cell_coadd) 

483 if alternates: 

484 if projection := alternates.get("projection"): 

485 compare_projection_to_legacy_wcs( 

486 tc, 

487 projection, 

488 legacy_stitched.wcs, 

489 TractFrame( 

490 skymap=legacy_cell_coadd.identifiers.skymap, 

491 tract=legacy_cell_coadd.identifiers.tract, 

492 bbox=tract_bbox, 

493 ), 

494 cell_coadd.bbox, 

495 is_fits=True, 

496 ) 

497 if psf := alternates.get("psf"): 

498 compare_psf_to_legacy(tc, psf, legacy_stitched.psf, points=psf_points) 

499 if provenance := alternates.get("provenance"): 

500 compare_cell_coadd_provenance_to_legacy(tc, provenance, legacy_cell_coadd) 

501 

502 

503def compare_cell_coadd_provenance_to_legacy( 

504 tc: unittest.TestCase, provenance: CoaddProvenance, legacy_cell_coadd: MultipleCellCoadd 

505) -> None: 

506 """Compare a `.cells.CoaddProvenance` object to a legacy 

507 `lsst.cell_coadds.MultipleCellCoadd` object. 

508 

509 Parameters 

510 ---------- 

511 tc 

512 Test case to use for asserts. 

513 provenance 

514 New provenance object to test. 

515 legacy_cell_coadd 

516 Legacy coadd to test against. 

517 """ 

518 from lsst.cell_coadds import ObservationIdentifiers 

519 

520 for legacy_cell in legacy_cell_coadd.cells.values(): 

521 cell_index = CellIJ.from_legacy(legacy_cell.identifiers.cell) 

522 prov = provenance[cell_index] 

523 legacy_table = astropy.table.Table( 

524 rows=[ 

525 [ 

526 ids.instrument, 

527 ids.visit, 

528 ids.detector, 

529 ids.day_obs, 

530 ids.physical_filter, 

531 legacy_input.overlaps_center, 

532 legacy_input.overlap_fraction, 

533 legacy_input.weight, 

534 legacy_input.psf_shape.getIxx(), 

535 legacy_input.psf_shape.getIyy(), 

536 legacy_input.psf_shape.getIxy(), 

537 legacy_input.psf_shape_flag, 

538 ] 

539 for ids, legacy_input in legacy_cell.inputs.items() 

540 ], 

541 dtype=[ 

542 np.object_, 

543 np.uint64, 

544 np.uint16, 

545 np.uint32, 

546 np.object_, 

547 np.bool_, 

548 np.float64, 

549 np.float64, 

550 np.float64, 

551 np.float64, 

552 np.float64, 

553 np.bool_, 

554 ], 

555 names=[ 

556 "instrument", 

557 "visit", 

558 "detector", 

559 "day_obs", 

560 "physical_filter", 

561 "overlaps_center", 

562 "overlap_fraction", 

563 "weight", 

564 "psf_shape_xx", 

565 "psf_shape_yy", 

566 "psf_shape_xy", 

567 "psf_shape_flag", 

568 ], 

569 ) 

570 # For a single cell all 'inputs' are also 'contributions'. 

571 tc.assertEqual(len(legacy_cell.inputs), len(prov.inputs)) 

572 tc.assertEqual(len(legacy_cell.inputs), len(prov.contributions)) 

573 prov.inputs.sort(["instrument", "visit", "detector"]) 

574 prov.contributions.sort(["instrument", "visit", "detector"]) 

575 legacy_table.sort(["instrument", "visit", "detector"]) 

576 np.testing.assert_array_equal(prov.inputs["instrument"], prov.contributions["instrument"]) 

577 np.testing.assert_array_equal(prov.inputs["visit"], prov.contributions["visit"]) 

578 np.testing.assert_array_equal(prov.inputs["detector"], prov.contributions["detector"]) 

579 np.testing.assert_array_equal(prov.inputs["instrument"], legacy_table["instrument"]) 

580 np.testing.assert_array_equal(prov.inputs["visit"], legacy_table["visit"]) 

581 np.testing.assert_array_equal(prov.inputs["detector"], legacy_table["detector"]) 

582 np.testing.assert_array_equal(prov.inputs["physical_filter"], legacy_table["physical_filter"]) 

583 np.testing.assert_array_equal(prov.inputs["day_obs"], legacy_table["day_obs"]) 

584 np.testing.assert_array_equal(prov.contributions["overlaps_center"], legacy_table["overlaps_center"]) 

585 np.testing.assert_array_equal( 

586 prov.contributions["overlap_fraction"], legacy_table["overlap_fraction"] 

587 ) 

588 np.testing.assert_array_equal(prov.contributions["weight"], legacy_table["weight"]) 

589 np.testing.assert_array_equal(prov.contributions["psf_shape_xx"], legacy_table["psf_shape_xx"]) 

590 np.testing.assert_array_equal(prov.contributions["psf_shape_yy"], legacy_table["psf_shape_yy"]) 

591 np.testing.assert_array_equal(prov.contributions["psf_shape_xy"], legacy_table["psf_shape_xy"]) 

592 np.testing.assert_array_equal(prov.contributions["psf_shape_flag"], legacy_table["psf_shape_flag"]) 

593 for row in prov.inputs: 

594 polygon_key = ObservationIdentifiers(**{k: row[k] for k in row.keys() if k != "polygon"}) 

595 legacy_polygon = legacy_cell_coadd.common.visit_polygons[polygon_key] 

596 tc.assertEqual(legacy_polygon, row["polygon"].to_legacy()) 

597 

598 

599def compare_psf_to_legacy( 

600 tc: unittest.TestCase, 

601 psf: PointSpreadFunction, 

602 legacy_psf: Any, 

603 points: YX[np.ndarray] | XY[np.ndarray] | None = None, 

604 expect_legacy_raise_on_out_of_bounds: bool = False, 

605) -> int: 

606 """Compare a PSF model object to its legacy interface. 

607 

608 Parameters 

609 ---------- 

610 tc 

611 Test case object with assert methods to use. 

612 psf 

613 Point-spread function to test. 

614 legacy_psf 

615 Legacy `lsst.afw.detection.Psf` instance to compare with. 

616 points 

617 Points to evaluate the PSFs at. If not provided, the intersection of 

618 the PSF bounding boxes are used to generate points on a grid. 

619 expect_legacy_raise_on_out_of_bounds 

620 If `True`, expect ``legacy_psf`` to raise 

621 `lsst.afw.detection.InvalidPsfError` when evaluated at a position 

622 considered out-of-bounds by ``psf``. 

623 

624 Returns 

625 ------- 

626 `int` 

627 The number of points actually tested. 

628 """ 

629 from lsst.afw.detection import InvalidPsfError 

630 

631 if points is None: 

632 points = psf.bounds.bbox.meshgrid(n=3).map(np.ravel) 

633 legacy_points = arrays_to_legacy_points(points.x, points.y) 

634 n_points_tested: int = 0 

635 for p in legacy_points: 

636 if not psf.bounds.contains(x=p.x, y=p.y): 

637 if expect_legacy_raise_on_out_of_bounds: 

638 with tc.assertRaises(InvalidPsfError): 

639 legacy_psf.computeKernelImage(p) 

640 continue 

641 tc.assertEqual(psf.kernel_bbox, Box.from_legacy(legacy_psf.computeKernelBBox(p))) 

642 tc.assertEqual( 

643 psf.compute_kernel_image(x=p.x, y=p.y), Image.from_legacy(legacy_psf.computeKernelImage(p)) 

644 ) 

645 tc.assertEqual( 

646 psf.compute_stellar_bbox(x=p.x, y=p.y), Box.from_legacy(legacy_psf.computeImageBBox(p)) 

647 ) 

648 tc.assertEqual(psf.compute_stellar_image(x=p.x, y=p.y), Image.from_legacy(legacy_psf.computeImage(p))) 

649 n_points_tested += 1 

650 return n_points_tested 

651 

652 

653def compare_field_to_legacy( 

654 tc: unittest.TestCase, 

655 field: BaseField, 

656 legacy_field: Any, 

657 subimage_bbox: Box, 

658) -> None: 

659 """Test a Field object by comparing it to an equivalent 

660 `lsst.afw.math.BoundedField`. 

661 

662 Parameters 

663 ---------- 

664 tc 

665 Test case object with assert methods to use. 

666 field 

667 Field to test. 

668 legacy_field : ``lsst.afw.math.BoundedField`` 

669 Equivalent legacy bounded field. 

670 subimage_bbox 

671 Bounding box for full-image tests. 

672 """ 

673 tc.assertEqual(field.bounds.bbox, Box.from_legacy(legacy_field.getBBox())) 

674 # Pixel coordinates to test the numpy array interface with. 

675 pixel_xy = field.bounds.bbox.meshgrid(n=5).map(np.ravel) 

676 assert_close(tc, field(x=pixel_xy.x, y=pixel_xy.y), legacy_field.evaluate(pixel_xy.x, pixel_xy.y)) 

677 legacy_image_1 = Image(0, bbox=subimage_bbox, dtype=np.float64).to_legacy() 

678 legacy_field.addToImage(legacy_image_1, overlapOnly=True) 

679 assert_images_equal( 

680 tc, field.render(subimage_bbox), Image.from_legacy(legacy_image_1, unit=field.unit), rtol=1e-13 

681 ) 

682 

683 

684def compare_aperture_corrections_to_legacy( 

685 tc: unittest.TestCase, 

686 aperture_corrections: ApertureCorrectionMap, 

687 legacy_ap_corr_map: Any, 

688 subimage_bbox: Box, 

689) -> None: 

690 """Test an aperture correction `dict` by comparing it to an equivalent 

691 `lsst.afw.image.ApCorrMap`. 

692 

693 Parameters 

694 ---------- 

695 tc 

696 Test case object with assert methods to use. 

697 aperture_corrections 

698 Dictionary to test. 

699 legacy_ap_corr_map : ``lsst.afw.image.ApCorrMap`` 

700 Equivalent legacy aperture correction map. 

701 subimage_bbox 

702 Bounding box for full-image tests. 

703 """ 

704 tc.assertEqual(aperture_corrections.keys(), set(legacy_ap_corr_map.keys())) 

705 for name, field in aperture_corrections.items(): 

706 compare_field_to_legacy(tc, field, legacy_ap_corr_map[name], subimage_bbox) 

707 

708 

709def compare_observation_summary_stats_to_legacy( 

710 tc: unittest.TestCase, 

711 summary_stats: ObservationSummaryStats, 

712 legacy_summary_stats: Any, 

713) -> None: 

714 """Test an ObservationSummaryStats object by comparing it to an equivalent 

715 `lsst.afw.image.ExposureSummaryStats`. 

716 

717 Parameters 

718 ---------- 

719 tc 

720 Test case object with assert methods to use. 

721 summary_stats 

722 Struct to test. 

723 legacy : ``lsst.afw.image.ExposureSummaryStats`` 

724 Equivalent legacy struct. 

725 """ 

726 for field in dataclasses.fields(legacy_summary_stats): 

727 a = getattr(legacy_summary_stats, field.name) 

728 b = getattr(summary_stats, field.name) 

729 if isinstance(b, tuple): 

730 for ai, bi in zip(a, b): 

731 tc.assertTrue(ai == bi or (math.isnan(ai) and math.isnan(bi)), f"{field.name}: {a} != {b}") 

732 else: 

733 tc.assertTrue(a == b or (math.isnan(a) and math.isnan(b)), f"{field.name}: {a} != {b}") 

734 

735 

736def compare_projection_to_legacy_wcs[F: Frame]( 

737 tc: unittest.TestCase, 

738 projection: Projection[F], 

739 legacy_wcs: Any, 

740 pixel_frame: F, 

741 subimage_bbox: Box, 

742 is_fits: bool = False, 

743) -> None: 

744 """Test a Projection object by comparing it to an equivalent 

745 `lsst.afw.geom.SkyWcs`. 

746 

747 Parameters 

748 ---------- 

749 tc 

750 Test case object with assert methods to use. 

751 projection 

752 Projection to test. 

753 legacy_wcs : ``lsst.afw.geom.SkyWcs`` 

754 Equivalent legacy WCS. 

755 pixel_frame 

756 Expected pixel frame for the projection. 

757 subimage_bbox 

758 Bounding box of points to generate for tests. 

759 is_fits 

760 Whether this projection is expected to be exactly representable as a 

761 FIT WCS. If `False` it is assumed to have a FITS approximation 

762 attached instead. 

763 """ 

764 # Pixel coordinates to test on over the subimage region of interest: 

765 pixel_xy = subimage_bbox.meshgrid(step=50).map(np.ravel)