# Licensed under a 3-clause BSD style license - see LICENSE.rst """Test sky projections defined in WCS Paper II""" # pylint: disable=invalid-name, no-member import os import unittest.mock as mk import numpy as np import pytest from numpy.testing import assert_allclose, assert_almost_equal from astropy import units as u from astropy import wcs from astropy.io import fits from astropy.modeling import projections from astropy.modeling.parameters import InputParameterError from astropy.tests.helper import assert_quantity_allclose from astropy.utils.data import get_pkg_data_filename def test_new_wcslib_projections(): # Test that we are aware of all WCSLIB projections. # Detect if a new WCSLIB release introduced new projections. assert not set(wcs.PRJ_CODES).symmetric_difference( projections.projcodes + projections._NOT_SUPPORTED_PROJ_CODES ) def test_Projection_properties(): projection = projections.Sky2Pix_PlateCarree() assert projection.n_inputs == 2 assert projection.n_outputs == 2 PIX_COORDINATES = [-10, 30] MAPS_DIR = os.path.join(os.pardir, os.pardir, "wcs", "tests", "data", "maps") pars = [(x,) for x in projections.projcodes] # There is no groundtruth file for the XPH projection available here: # https://www.atnf.csiro.au/people/mcalabre/WCS/example_data.html pars.remove(("XPH",)) @pytest.mark.parametrize(("code",), pars) def test_Sky2Pix(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{code}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = f"PV2_{i + 1}" if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0.0, 0.0] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_pix = w.wcs.s2p(wcslibout["world"], 1)["pixcrd"] model = getattr(projections, "Sky2Pix_" + code) tinv = model(*params) x, y = tinv(wcslibout["phi"], wcslibout["theta"]) assert_almost_equal(np.asarray(x), wcs_pix[:, 0]) assert_almost_equal(np.asarray(y), wcs_pix[:, 1]) assert isinstance(tinv.prjprm, wcs.Prjprm) @pytest.mark.parametrize(("code",), pars) def test_Pix2Sky(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{code}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = f"PV2_{i + 1}" if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0.0, 0.0] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_phi = wcslibout["phi"] wcs_theta = wcslibout["theta"] model = getattr(projections, "Pix2Sky_" + code) tanprj = model(*params) phi, theta = tanprj(*PIX_COORDINATES) assert_almost_equal(np.asarray(phi), wcs_phi) assert_almost_equal(np.asarray(theta), wcs_theta) @pytest.mark.parametrize(("code",), pars) def test_Sky2Pix_unit(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{code}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = f"PV2_{i + 1}" if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0.0, 0.0] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_pix = w.wcs.s2p(wcslibout["world"], 1)["pixcrd"] model = getattr(projections, "Sky2Pix_" + code) tinv = model(*params) x, y = tinv(wcslibout["phi"] * u.deg, wcslibout["theta"] * u.deg) assert_quantity_allclose(x, wcs_pix[:, 0] * u.deg) assert_quantity_allclose(y, wcs_pix[:, 1] * u.deg) @pytest.mark.parametrize(("code",), pars) def test_Pix2Sky_unit(code): """Check astropy model eval against wcslib eval""" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{code}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) params = [] for i in range(3): key = f"PV2_{i + 1}" if key in header: params.append(header[key]) w = wcs.WCS(header) w.wcs.crval = [0.0, 0.0] w.wcs.crpix = [0, 0] w.wcs.cdelt = [1, 1] wcslibout = w.wcs.p2s([PIX_COORDINATES], 1) wcs_phi = wcslibout["phi"] wcs_theta = wcslibout["theta"] model = getattr(projections, "Pix2Sky_" + code) tanprj = model(*params) phi, theta = tanprj(*PIX_COORDINATES * u.deg) assert_quantity_allclose(phi, wcs_phi * u.deg) assert_quantity_allclose(theta, wcs_theta * u.deg) phi, theta = tanprj(*(PIX_COORDINATES * u.deg).to(u.rad)) assert_quantity_allclose(phi, wcs_phi * u.deg) assert_quantity_allclose(theta, wcs_theta * u.deg) phi, theta = tanprj(*(PIX_COORDINATES * u.deg).to(u.arcmin)) assert_quantity_allclose(phi, wcs_phi * u.deg) assert_quantity_allclose(theta, wcs_theta * u.deg) @pytest.mark.parametrize(("code",), pars) def test_projection_default(code): """Check astropy model eval with default parameters""" # Just makes sure that the default parameter values are reasonable # and accepted by wcslib. model = getattr(projections, "Sky2Pix_" + code) tinv = model() x, y = tinv(45, 45) model = getattr(projections, "Pix2Sky_" + code) tinv = model() x, y = tinv(0, 0) class TestZenithalPerspective: """Test Zenithal Perspective projection""" def setup_class(self): ID = "AZP" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{ID}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) self.wazp = wcs.WCS(header) self.wazp.wcs.crpix = np.array([0.0, 0.0]) self.wazp.wcs.crval = np.array([0.0, 0.0]) self.wazp.wcs.cdelt = np.array([1.0, 1.0]) self.pv_kw = [kw[2] for kw in self.wazp.wcs.get_pv()] self.azp = projections.Pix2Sky_ZenithalPerspective(*self.pv_kw) def test_AZP_p2s(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_phi = wcslibout["phi"] wcs_theta = wcslibout["theta"] phi, theta = self.azp(-10, 30) assert_almost_equal(np.asarray(phi), wcs_phi) assert_almost_equal(np.asarray(theta), wcs_theta) def test_AZP_s2p(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_pix = self.wazp.wcs.s2p(wcslibout["world"], 1)["pixcrd"] x, y = self.azp.inverse(wcslibout["phi"], wcslibout["theta"]) assert_almost_equal(np.asarray(x), wcs_pix[:, 0]) assert_almost_equal(np.asarray(y), wcs_pix[:, 1]) def test_validate(self): MESSAGE = r"Zenithal perspective projection is not defined for mu = -1" with pytest.raises(InputParameterError, match=MESSAGE): projections.Pix2Sky_ZenithalPerspective(-1) with pytest.raises(InputParameterError, match=MESSAGE): projections.Sky2Pix_ZenithalPerspective(-1) with pytest.raises(InputParameterError, match=MESSAGE): projections.Pix2Sky_SlantZenithalPerspective(-1) with pytest.raises(InputParameterError, match=MESSAGE): projections.Sky2Pix_SlantZenithalPerspective(-1) class TestCylindricalPerspective: """Test cylindrical perspective projection""" def setup_class(self): ID = "CYP" wcs_map = os.path.join(MAPS_DIR, f"1904-66_{ID}.hdr") test_file = get_pkg_data_filename(wcs_map) header = fits.Header.fromfile(test_file, endcard=False, padding=False) self.wazp = wcs.WCS(header) self.wazp.wcs.crpix = np.array([0.0, 0.0]) self.wazp.wcs.crval = np.array([0.0, 0.0]) self.wazp.wcs.cdelt = np.array([1.0, 1.0]) self.pv_kw = [kw[2] for kw in self.wazp.wcs.get_pv()] self.azp = projections.Pix2Sky_CylindricalPerspective(*self.pv_kw) def test_CYP_p2s(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_phi = wcslibout["phi"] wcs_theta = wcslibout["theta"] phi, theta = self.azp(-10, 30) assert_almost_equal(np.asarray(phi), wcs_phi) assert_almost_equal(np.asarray(theta), wcs_theta) def test_CYP_s2p(self): wcslibout = self.wazp.wcs.p2s([[-10, 30]], 1) wcs_pix = self.wazp.wcs.s2p(wcslibout["world"], 1)["pixcrd"] x, y = self.azp.inverse(wcslibout["phi"], wcslibout["theta"]) assert_almost_equal(np.asarray(x), wcs_pix[:, 0]) assert_almost_equal(np.asarray(y), wcs_pix[:, 1]) def test_validate(self): MESSAGE = r"CYP projection is not defined for .*" MESSAGE0 = r"CYP projection is not defined for mu = -lambda" MESSAGE1 = r"CYP projection is not defined for lambda = -mu" # Pix2Sky_CylindricalPerspective with pytest.raises(InputParameterError, match=MESSAGE): projections.Pix2Sky_CylindricalPerspective(1, -1) with pytest.raises(InputParameterError, match=MESSAGE): projections.Pix2Sky_CylindricalPerspective(-1, 1) model = projections.Pix2Sky_CylindricalPerspective() with pytest.raises(InputParameterError, match=MESSAGE0): model.mu = -1 with pytest.raises(InputParameterError, match=MESSAGE1): model.lam = -1 # Sky2Pix_CylindricalPerspective with pytest.raises(InputParameterError, match=MESSAGE): projections.Sky2Pix_CylindricalPerspective(1, -1) with pytest.raises(InputParameterError, match=MESSAGE): projections.Sky2Pix_CylindricalPerspective(-1, 1) model = projections.Sky2Pix_CylindricalPerspective() with pytest.raises(InputParameterError, match=MESSAGE0): model.mu = -1 with pytest.raises(InputParameterError, match=MESSAGE1): model.lam = -1 def test_AffineTransformation2D(): # Simple test with a scale and translation model = projections.AffineTransformation2D( matrix=[[2, 0], [0, 2]], translation=[1, 1] ) # Coordinates for vertices of a rectangle rect = [[0, 0], [1, 0], [0, 3], [1, 3]] x, y = zip(*rect) new_rect = np.vstack(model(x, y)).T assert np.all(new_rect == [[1, 1], [3, 1], [1, 7], [3, 7]]) # Matrix validation error MESSAGE = r"Expected transformation matrix to be a 2x2 array" with pytest.raises(InputParameterError, match=MESSAGE): model.matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # Translation validation error MESSAGE = ( r"Expected translation vector to be a 2 element row or column vector array" ) with pytest.raises(InputParameterError, match=MESSAGE): model.translation = [1, 2, 3] with pytest.raises(InputParameterError, match=MESSAGE): model.translation = [[1], [2]] with pytest.raises(InputParameterError, match=MESSAGE): model.translation = [[1, 2, 3]] # Incompatible shape error a = np.array([[1], [2], [3], [4]]) b = a.ravel() with mk.patch.object(np, "vstack", autospec=True, side_effect=[a, b]) as mk_vstack: MESSAGE = r"Incompatible input shapes" with pytest.raises(ValueError, match=MESSAGE): model(x, y) with pytest.raises(ValueError, match=MESSAGE): model(x, y) assert mk_vstack.call_count == 2 # Input shape evaluation error x = np.array([1, 2]) y = np.array([1, 2, 3]) MESSAGE = r"Expected input arrays to have the same shape" with pytest.raises(ValueError, match=MESSAGE): model.evaluate(x, y, model.matrix, model.translation) def test_AffineTransformation2D_inverse(): # Test non-invertible model model1 = projections.AffineTransformation2D(matrix=[[1, 1], [1, 1]]) MESSAGE = r"Transformation matrix is singular; .* model does not have an inverse" with pytest.raises(InputParameterError, match=MESSAGE): model1.inverse model2 = projections.AffineTransformation2D( matrix=[[1.2, 3.4], [5.6, 7.8]], translation=[9.1, 10.11] ) # Coordinates for vertices of a rectangle rect = [[0, 0], [1, 0], [0, 3], [1, 3]] x, y = zip(*rect) x_new, y_new = model2.inverse(*model2(x, y)) assert_allclose([x, y], [x_new, y_new], atol=1e-10) model3 = projections.AffineTransformation2D( matrix=[[1.2, 3.4], [5.6, 7.8]] * u.m, translation=[9.1, 10.11] * u.m ) x_new, y_new = model3.inverse(*model3(x * u.m, y * u.m)) assert_allclose([x, y], [x_new, y_new], atol=1e-10) model4 = projections.AffineTransformation2D( matrix=[[1.2, 3.4], [5.6, 7.8]] * u.m, translation=[9.1, 10.11] * u.km ) MESSAGE = r"matrix and translation must have the same units" with pytest.raises(ValueError, match=MESSAGE): model4.inverse(*model4(x * u.m, y * u.m)) def test_c_projection_striding(): # This is just a simple test to make sure that the striding is # handled correctly in the projection C extension coords = np.arange(10).reshape((5, 2)) model = projections.Sky2Pix_ZenithalPerspective(2, 30) phi, theta = model(coords[:, 0], coords[:, 1]) assert_almost_equal(phi, [0.0, 2.2790416, 4.4889294, 6.6250643, 8.68301]) assert_almost_equal( theta, [-76.4816918, -75.3594654, -74.1256332, -72.784558, -71.3406629] ) def test_c_projections_shaped(): nx, ny = (5, 2) x = np.linspace(0, 1, nx) y = np.linspace(0, 1, ny) xv, yv = np.meshgrid(x, y) model = projections.Pix2Sky_TAN() phi, theta = model(xv, yv) assert_allclose( phi, [ [0.0, 90.0, 90.0, 90.0, 90.0], [180.0, 165.96375653, 153.43494882, 143.13010235, 135.0], ], ) assert_allclose( theta, [ [90.0, 89.75000159, 89.50001269, 89.25004283, 89.00010152], [89.00010152, 88.96933478, 88.88210788, 88.75019826, 88.58607353], ], ) def test_affine_with_quantities(): x = 1 y = 2 xdeg = (x * u.pix).to(u.deg, equivalencies=u.pixel_scale(2.5 * u.deg / u.pix)) ydeg = (y * u.pix).to(u.deg, equivalencies=u.pixel_scale(2.5 * u.deg / u.pix)) xpix = x * u.pix ypix = y * u.pix # test affine with matrix only qaff = projections.AffineTransformation2D(matrix=[[1, 2], [2, 1]] * u.deg) MESSAGE = ( r"To use AffineTransformation with quantities, both matrix and unit need to be" r" quantities" ) with pytest.raises(ValueError, match=MESSAGE): qx1, qy1 = qaff( xpix, ypix, equivalencies={ "x": u.pixel_scale(2.5 * u.deg / u.pix), "y": u.pixel_scale(2.5 * u.deg / u.pix), }, ) # test affine with matrix and translation qaff = projections.AffineTransformation2D( matrix=[[1, 2], [2, 1]] * u.deg, translation=[1, 2] * u.deg ) qx1, qy1 = qaff( xpix, ypix, equivalencies={ "x": u.pixel_scale(2.5 * u.deg / u.pix), "y": u.pixel_scale(2.5 * u.deg / u.pix), }, ) aff = projections.AffineTransformation2D( matrix=[[1, 2], [2, 1]], translation=[1, 2] ) x1, y1 = aff(xdeg.value, ydeg.value) assert_quantity_allclose(qx1, x1 * u.deg) assert_quantity_allclose(qy1, y1 * u.deg) # test the case of WCS PC and CDELT transformations pc = np.array( [ [0.86585778922708, 0.50029020461607], [-0.50029020461607, 0.86585778922708], ] ) cdelt = np.array( [ [1, 3.0683055555556e-05], [3.0966944444444e-05, 1], ] ) matrix = cdelt * pc qaff = projections.AffineTransformation2D( matrix=matrix * u.deg, translation=[0, 0] * u.deg ) inv_matrix = np.linalg.inv(matrix) inv_qaff = projections.AffineTransformation2D( matrix=inv_matrix * u.pix, translation=[0, 0] * u.pix ) qaff.inverse = inv_qaff qx1, qy1 = qaff( xpix, ypix, equivalencies={ "x": u.pixel_scale(1 * u.deg / u.pix), "y": u.pixel_scale(1 * u.deg / u.pix), }, ) x1, y1 = qaff.inverse( qx1, qy1, equivalencies={ "x": u.pixel_scale(1 * u.deg / u.pix), "y": u.pixel_scale(1 * u.deg / u.pix), }, ) assert_quantity_allclose(x1, xpix) assert_quantity_allclose(y1, ypix) def test_Pix2Sky_ZenithalPerspective_inverse(): model = projections.Pix2Sky_ZenithalPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ZenithalPerspective) assert inverse.mu == model.mu == 2 assert_allclose(inverse.gamma, model.gamma) assert_allclose(inverse.gamma, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ZenithalPerspective_inverse(): model = projections.Sky2Pix_ZenithalPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_AZP) assert inverse.mu == model.mu == 2 assert_allclose(inverse.gamma, model.gamma) assert_allclose(inverse.gamma, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_SlantZenithalPerspective_inverse(): model = projections.Pix2Sky_SlantZenithalPerspective(2, 30, 40) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_SlantZenithalPerspective) assert inverse.mu == model.mu == 2 assert_allclose(inverse.phi0, model.phi0) assert_allclose(inverse.theta0, model.theta0) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_SlantZenithalPerspective_inverse(): model = projections.Sky2Pix_SlantZenithalPerspective(2, 30, 40) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_SlantZenithalPerspective) assert inverse.mu == model.mu == 2 assert_allclose(inverse.phi0, model.phi0) assert_allclose(inverse.theta0, model.theta0) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Gnomonic_inverse(): model = projections.Pix2Sky_Gnomonic() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Gnomonic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Gnomonic_inverse(): model = projections.Sky2Pix_Gnomonic() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Gnomonic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Stereographic_inverse(): model = projections.Pix2Sky_Stereographic() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Stereographic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Stereographic_inverse(): model = projections.Sky2Pix_Stereographic() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Stereographic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_SlantOrthographic_inverse(): model = projections.Pix2Sky_SlantOrthographic(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_SlantOrthographic) assert inverse.xi == model.xi == 2 assert inverse.eta == model.eta == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-8) assert_allclose(b, y, atol=1e-8) def test_Sky2Pix_SlantOrthographic_inverse(): model = projections.Sky2Pix_SlantOrthographic(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_SlantOrthographic) assert inverse.xi == model.xi == 2 assert inverse.eta == model.eta == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-8) assert_allclose(b, y, atol=1e-8) def test_Pix2Sky_ZenithalEquidistant_inverse(): model = projections.Pix2Sky_ZenithalEquidistant() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ZenithalEquidistant) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ZenithalEquidistant_inverse(): model = projections.Sky2Pix_ZenithalEquidistant() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ZenithalEquidistant) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_ZenithalEqualArea_inverse(): model = projections.Pix2Sky_ZenithalEqualArea() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ZenithalEqualArea) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ZenithalEqualArea_inverse(): model = projections.Sky2Pix_ZenithalEqualArea() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ZenithalEqualArea) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Airy_inverse(): model = projections.Pix2Sky_Airy(30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Airy) assert inverse.theta_b == model.theta_b == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Airy_inverse(): model = projections.Sky2Pix_Airy(30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Airy) assert inverse.theta_b == model.theta_b == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_CylindricalPerspective_inverse(): model = projections.Pix2Sky_CylindricalPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_CylindricalPerspective) assert inverse.mu == model.mu == 2 assert inverse.lam == model.lam == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_CylindricalPerspective_inverse(): model = projections.Sky2Pix_CylindricalPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_CylindricalPerspective) assert inverse.mu == model.mu == 2 assert inverse.lam == model.lam == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_CylindricalEqualArea_inverse(): model = projections.Pix2Sky_CylindricalEqualArea(0.567) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_CylindricalEqualArea) assert inverse.lam == model.lam == 0.567 def test_Sky2Pix_CylindricalEqualArea_inverse(): model = projections.Sky2Pix_CylindricalEqualArea(0.765) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_CylindricalEqualArea) assert inverse.lam == model.lam == 0.765 def test_Pix2Sky_PlateCarree_inverse(): model = projections.Pix2Sky_PlateCarree() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_PlateCarree) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_PlateCarree_inverse(): model = projections.Sky2Pix_PlateCarree() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_PlateCarree) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Mercator_inverse(): model = projections.Pix2Sky_Mercator() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Mercator) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Mercator_inverse(): model = projections.Sky2Pix_Mercator() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Mercator) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_SansonFlamsteed_inverse(): model = projections.Pix2Sky_SansonFlamsteed() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_SansonFlamsteed) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_SansonFlamsteed_inverse(): model = projections.Sky2Pix_SansonFlamsteed() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_SansonFlamsteed) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Parabolic_inverse(): model = projections.Pix2Sky_Parabolic() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Parabolic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Parabolic_inverse(): model = projections.Sky2Pix_Parabolic() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Parabolic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Molleweide_inverse(): model = projections.Pix2Sky_Molleweide() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Molleweide) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Molleweide_inverse(): model = projections.Sky2Pix_Molleweide() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Molleweide) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_HammerAitoff_inverse(): model = projections.Pix2Sky_HammerAitoff() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_HammerAitoff) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_HammerAitoff_inverse(): model = projections.Sky2Pix_HammerAitoff() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_HammerAitoff) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_ConicPerspective_inverse(): model = projections.Pix2Sky_ConicPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ConicPerspective) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ConicPerspective_inverse(): model = projections.Sky2Pix_ConicPerspective(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ConicPerspective) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_ConicEqualArea_inverse(): model = projections.Pix2Sky_ConicEqualArea(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ConicEqualArea) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ConicEqualArea_inverse(): model = projections.Sky2Pix_ConicEqualArea(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ConicEqualArea) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_ConicEquidistant_inverse(): model = projections.Pix2Sky_ConicEquidistant(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ConicEquidistant) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ConicEquidistant_inverse(): model = projections.Sky2Pix_ConicEquidistant(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ConicEquidistant) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_ConicOrthomorphic_inverse(): model = projections.Pix2Sky_ConicOrthomorphic(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_ConicOrthomorphic) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_ConicOrthomorphic_inverse(): model = projections.Sky2Pix_ConicOrthomorphic(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_ConicOrthomorphic) assert inverse.sigma == model.sigma == 2 assert_allclose(inverse.delta, model.delta) assert_allclose(inverse.delta, 30) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_BonneEqualArea_inverse(): model = projections.Pix2Sky_BonneEqualArea(2) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_BonneEqualArea) assert inverse.theta1 == model.theta1 == 2 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_BonneEqualArea_inverse(): model = projections.Sky2Pix_BonneEqualArea(2) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_BonneEqualArea) assert inverse.theta1 == model.theta1 == 2 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_Polyconic_inverse(): model = projections.Pix2Sky_Polyconic() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_Polyconic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_Polyconic_inverse(): model = projections.Sky2Pix_Polyconic() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_Polyconic) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_TangentialSphericalCube_inverse(): model = projections.Pix2Sky_TangentialSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_TangentialSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_TangentialSphericalCube_inverse(): model = projections.Sky2Pix_TangentialSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_TangentialSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_COBEQuadSphericalCube_inverse(): model = projections.Pix2Sky_COBEQuadSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_COBEQuadSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-3) assert_allclose(b, y, atol=1e-3) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-3) assert_allclose(b, y, atol=1e-3) def test_Sky2Pix_COBEQuadSphericalCube_inverse(): model = projections.Sky2Pix_COBEQuadSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_COBEQuadSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-3) assert_allclose(b, y, atol=1e-3) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-3) assert_allclose(b, y, atol=1e-3) def test_Pix2Sky_QuadSphericalCube_inverse(): model = projections.Pix2Sky_QuadSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_QuadSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_QuadSphericalCube_inverse(): model = projections.Sky2Pix_QuadSphericalCube() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_QuadSphericalCube) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_HEALPix_inverse(): model = projections.Pix2Sky_HEALPix(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_HEALPix) assert inverse.H == model.H == 2 assert inverse.X == model.X == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_HEALPix_inverse(): model = projections.Sky2Pix_HEALPix(2, 30) inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_HEALPix) assert inverse.H == model.H == 2 assert inverse.X == model.X == 30 x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Pix2Sky_HEALPixPolar_inverse(): model = projections.Pix2Sky_HEALPixPolar() inverse = model.inverse assert isinstance(inverse, projections.Sky2Pix_HEALPixPolar) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) def test_Sky2Pix_HEALPixPolar_inverse(): model = projections.Sky2Pix_HEALPixPolar() inverse = model.inverse assert isinstance(inverse, projections.Pix2Sky_HEALPixPolar) x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) a, b = model(*inverse(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12) a, b = inverse(*model(x, y)) assert_allclose(a, x, atol=1e-12) assert_allclose(b, y, atol=1e-12)