def _get_matrix_vectors(gal_frame, inverse=False):
"""
Utility function: use the ``inverse`` argument to get the inverse transformation, matrix and
offsets to go from external galaxy frame to ICRS.
"""
# this is based on the astropy Galactocentric class code
# shorthand
gcf = gal_frame
# rotation matrix to align x(ICRS) with the vector to the galaxy center
mat0 = np.array([[0., 1., 0.],
[0., 0., 1.],
[1., 0., 0.]]) # relabel axes so x points in RA, y in dec, z away from us
mat1 = rotation_matrix(-gcf.gal_coord.dec, 'y')
mat2 = rotation_matrix(gcf.gal_coord.ra, 'z')
# construct transformation matrix and use it
R = matrix_product(mat0, mat1, mat2)
# Now define translation by distance to galaxy center - best defined in current sky coord system defined by R
translation = r.CartesianRepresentation(gcf.gal_distance * [0., 0., 1.])
# Now rotate galaxy to right orientation
pa_rot = rotation_matrix(-gcf.PA, 'z')
inc_rot = rotation_matrix(gcf.inclination, 'y')
H = matrix_product(inc_rot, pa_rot)
# compute total matrices
A = matrix_product(H, R)
# Now we transform the translation vector between sky-aligned and galaxy-aligned frames
offset = -translation.transform(H)
if inverse:
# the inverse of a rotation matrix is a transpose, which is much faster
# and more stable to compute
A = matrix_transpose(A)
offset = (-offset).transform(A)
# galvel is given in sky-aligned coords, need to transform to ICRS, so use R transpose
R = matrix_transpose(R)
offset_v = r.CartesianDifferential.from_cartesian(
(gcf.galvel_heliocentric).to_cartesian().transform(R))
offset = offset.with_differentials(offset_v)
else:
# galvel is given in sky-aligned coords, need to transform to gal frame, so use H
offset_v = r.CartesianDifferential.from_cartesian(
(-gcf.galvel_heliocentric).to_cartesian().transform(H))
offset = offset.with_differentials(offset_v)
return A, offset
def greatcircle_to_reference(greatcircle_coord, reference_frame):
"""Convert an great circle frame coordinate to the reference frame"""
# use the forward transform, but just invert it
R = reference_to_greatcircle(reference_frame, greatcircle_coord)
# transpose is the inverse because R is a rotation matrix
return matrix_transpose(R)
def hpc_to_hcc(heliopcoord, heliocframe):
"""
Convert from Helioprojective Cartesian to Heliocentric Cartesian.
"""
_check_observer_defined(heliopcoord)
_check_observer_defined(heliocframe)
heliopcoord = heliopcoord.make_3d()
# Permute/swap axes from HPC equivalent Cartesian to HCC
newrepr = heliopcoord.cartesian.transform(
matrix_transpose(_matrix_hcc_to_hpc()))
# Transform the HPC observer (in HGS) to the HPC obstime in case it's different
observer = _transform_obstime(heliopcoord.observer, heliopcoord.obstime)
# Shift the origin from the observer to the Sun
distance = observer.radius
newrepr += CartesianRepresentation(0 * u.m, 0 * u.m, distance)
# Complete the conversion of HPC to HCC at the obstime and observer of the HPC coord
int_coord = Heliocentric(newrepr,
obstime=observer.obstime,
observer=observer)
# Loopback transform HCC as needed
return int_coord.transform_to(heliocframe)
def geoecliptic_to_gcrs(from_coo, gcrs_frame):
rmat = _ecliptic_rotation_matrix(from_coo.equinox)
newrepr = from_coo.cartesian.transform(matrix_transpose(rmat))
gcrs = GCRS(newrepr, obstime=from_coo.equinox)
# now do any needed offsets (no-op if same obstime and 0 pos/vel)
return gcrs.transform_to(gcrs_frame)
def skyoffset_to_reference(skyoffset_coord, reference_frame):
'''Convert an sky offset frame coordinate to the reference frame'''
# use the forward transform, but just invert it
mat = reference_to_skyoffset(reference_frame, skyoffset_coord)
# transpose is the inverse because mat is a rotation matrix
return matrix_transpose(mat)
def geoecliptic_to_gcrs(from_coo, gcrs_frame):
rmat = _mean_ecliptic_rotation_matrix(from_coo.equinox)
newrepr = from_coo.cartesian.transform(matrix_transpose(rmat))
gcrs = GCRS(newrepr, obstime=from_coo.obstime)
# now do any needed offsets (no-op if same obstime and 0 pos/vel)
return gcrs.transform_to(gcrs_frame)
def offset_to_reference(offset_coord, reference_frame):
"""Convert an sky offset frame coordinate to the reference frame"""
# use the forward transform, but just invert it
R = reference_to_offset(reference_frame, offset_coord)
# transpose is the inverse because R is a rotation matrix
return matrix_transpose(R)
def hme_to_gei(hmecoord, geiframe):
"""
Convert from Heliocentric Mean Ecliptic to Geocentric Earth Equatorial
"""
if geiframe.obstime is None:
raise ConvertError("To perform this transformation, the coordinate"
" frame needs a specified `obstime`.")
# Use an intermediate frame of HME at the GEI observation time, through HCRS
int_frame = HeliocentricMeanEcliptic(obstime=geiframe.obstime,
equinox=geiframe.equinox)
int_coord = hmecoord.transform_to(
HCRS(obstime=int_frame.obstime)).transform_to(int_frame)
# Get the Sun-Earth vector in the intermediate frame
sun_earth = HCRS(_sun_earth_icrf(int_frame.obstime),
obstime=int_frame.obstime)
sun_earth_int = sun_earth.transform_to(int_frame).cartesian
# Find the Earth-object vector in the intermediate frame
earth_object_int = int_coord.cartesian - sun_earth_int
# Rotate from ecliptic to Earth equatorial
rot_matrix = matrix_transpose(_rotation_matrix_obliquity(
int_frame.equinox))
newrepr = earth_object_int.transform(rot_matrix)
return geiframe.realize_frame(newrepr)
def cust_to_icrs():
"""Register matrix transformation.
Does ICRS-rotated custom to ICRS spherical coordinates
"""
return matrix_transpose(R_icrs_to_cust)
def hpc_to_hcc(heliopcoord, heliocframe):
"""
Convert from Helioprojective Cartesian to Heliocentric Cartesian.
"""
if not isinstance(heliopcoord.observer, BaseCoordinateFrame):
raise ConvertError("Cannot transform helioprojective coordinates to "
"heliocentric coordinates for observer '{}' "
"without `obstime` being specified.".format(
heliopcoord.observer))
heliopcoord = heliopcoord.calculate_distance()
# Permute/swap axes from HPC equivalent Cartesian to HCC
newrepr = heliopcoord.cartesian.transform(
matrix_transpose(_matrix_hcc_to_hpc()))
# Shift the origin from the observer to the Sun
distance = heliocframe.observer.radius
newrepr += CartesianRepresentation(0 * u.m, 0 * u.m, distance)
# Complete the conversion of HPC to HCC at the obstime and observer of the HPC coord
int_coord = Heliocentric(newrepr,
obstime=heliopcoord.obstime,
observer=heliopcoord.observer)
# Loopback transform HCC as needed
return int_coord.transform_to(heliocframe)
def hgs_to_hcrs(hgscoord, hcrsframe):
"""
Convert from Heliographic Stonyhurst to HCRS.
Even though we calculate the parameters for the affine transform, we use
``FunctionTransformWithFiniteDifference`` because otherwise there is no way to account for the
induced angular velocity when transforming a coordinate with velocity information.
"""
if hgscoord.obstime is None:
raise ConvertError(
"To perform this transformation, the HeliographicStonyhurst"
" frame needs a specified `obstime`.")
hgscoord = hgscoord.make_3d()
# Calculate the matrix and offset in the HCRS->HGS direction
forward_matrix, forward_offset = _affine_params_hcrs_to_hgs(
hcrsframe.obstime, hgscoord.obstime)
# Invert the transformation to get the HGS->HCRS transformation
reverse_matrix = matrix_transpose(forward_matrix)
reverse_offset = -forward_offset
return hcrsframe.realize_frame(
hgscoord.cartesian.transform(reverse_matrix) + reverse_offset)
def itrs_to_teme(itrs_coo, teme_frame):
# transform the ITRS coordinate to the target obstime
itrs_coo2 = itrs_coo.transform_to(ITRS(obstime=teme_frame.obstime))
# compute the pmatrix, and then multiply by its transpose
pmat = teme_to_itrs_mat(teme_frame.obstime)
newrepr = itrs_coo2.cartesian.transform(matrix_transpose(pmat))
return teme_frame.realize_frame(newrepr)
def cirs_to_gcrs(cirs_coo, gcrs_frame):
# compute the pmatrix, and then multiply by its transpose
pmat = gcrs_to_cirs_mat(cirs_coo.obstime)
newrepr = cirs_coo.cartesian.transform(matrix_transpose(pmat))
gcrs = GCRS(newrepr, obstime=cirs_coo.obstime)
# now do any needed offsets (no-op if same obstime and 0 pos/vel)
return gcrs.transform_to(gcrs_frame)
def itrs_to_teme(itrs_coo, teme_frame):
# compute the pmatrix, and then multiply by its transpose
pmat = teme_to_itrs_mat(itrs_coo.obstime)
newrepr = itrs_coo.cartesian.transform(matrix_transpose(pmat))
teme = TEME(newrepr, obstime=itrs_coo.obstime)
# now do any needed offsets (no-op if same obstime)
return teme.transform_to(teme_frame)
def itrs_to_cirs(itrs_coo, cirs_frame):
# compute the pmatrix, and then multiply by its transpose
pmat = cirs_to_itrs_mat(itrs_coo.obstime)
newrepr = itrs_coo.cartesian.transform(matrix_transpose(pmat))
cirs = CIRS(newrepr, obstime=itrs_coo.obstime)
# now do any needed offsets (no-op if same obstime)
return cirs.transform_to(cirs_frame)
def cirs_to_gcrs(cirs_coo, gcrs_frame):
# compute the pmatrix, and then multiply by its transpose
pmat = gcrs_to_cirs_mat(cirs_coo.obstime)
newrepr = cirs_coo.cartesian.transform(matrix_transpose(pmat))
gcrs = GCRS(newrepr, obstime=cirs_coo.obstime)
# now do any needed offsets (no-op if same obstime and 0 pos/vel)
return gcrs.transform_to(gcrs_frame)
def itrs_to_cirs(itrs_coo, cirs_frame):
# compute the pmatrix, and then multiply by its transpose
pmat = cirs_to_itrs_mat(itrs_coo.obstime)
newrepr = itrs_coo.cartesian.transform(matrix_transpose(pmat))
cirs = CIRS(newrepr, obstime=itrs_coo.obstime)
# now do any needed offsets (no-op if same obstime)
return cirs.transform_to(cirs_frame)
def ecliptic_to_iau76_icrs(from_coo, to_frame):
# first un-precess from ecliptic to ICRS orientation
rmat = _obliquity_only_rotation_matrix()
# now offset back to barycentric, which is the correct center for ICRS
sun_from_ssb = get_offset_sun_from_barycenter(
from_coo.obstime, include_velocity=bool(from_coo.data.differentials))
return matrix_transpose(rmat), sun_from_ssb
def precessedgeo_to_gcrs(from_coo, to_frame):
# first un-precess
pmat = gcrs_precession_mat(from_coo.equinox)
crepr = from_coo.cartesian.transform(matrix_transpose(pmat))
gcrs_coo = GCRS(crepr, obstime=to_frame.obstime,
obsgeoloc=to_frame.obsgeoloc,
obsgeovel=to_frame.obsgeovel)
# then move to the GCRS that's actually desired
return gcrs_coo.transform_to(to_frame)
def cirs_to_gcrs(cirs_coo, gcrs_frame):
# Compute the pmatrix, and then multiply by its transpose,
pmat = gcrs_to_cirs_mat(cirs_coo.obstime)
newrepr = cirs_coo.cartesian.transform(matrix_transpose(pmat))
# We now have a GCRS vector for the input location and obstime.
# Turn it into a GCRS frame instance.
loc_gcrs = get_location_gcrs(cirs_coo, pmat)
gcrs = loc_gcrs.realize_frame(newrepr)
# Finally, do any needed offsets (no-op if same obstime and location)
return gcrs.transform_to(gcrs_frame)
def tete_to_gcrs(tete_coo, gcrs_frame):
# Compute the pn matrix, and then multiply by its transpose.
rbpn = erfa.pnm06a(*get_jd12(tete_coo.obstime, 'tt'))
newrepr = tete_coo.cartesian.transform(matrix_transpose(rbpn))
# We now have a GCRS vector for the input location and obstime.
# Turn it into a GCRS frame instance.
loc_gcrs = get_location_gcrs(tete_coo, rbpn)
gcrs = loc_gcrs.realize_frame(newrepr)
# Finally, do any needed offsets (no-op if same obstime and location)
return gcrs.transform_to(gcrs_frame)
def _ecliptic_to_icrs(from_coo, to_frame):
# first un-precess from ecliptic to ICRS orientation
rmat = _ecliptic_rotation_matrix()
intermed_repr = from_coo.cartesian.transform(matrix_transpose(rmat))
# now offset back to barycentric, which is the correct center for ICRS
# get barycentric sun coordinate
bary_sun_pos = get_body_barycentric("sun", from_coo.obstime)
newrepr = intermed_repr + bary_sun_pos
return to_frame.realize_frame(newrepr)
def fk5_to_fk4_no_e(fk5coord, fk4noeframe):
# Get transposed version of the rotating correction terms... so with the
# transpose this takes us from FK5/J200 to FK4/B1950
B = matrix_transpose(_fk4_B_matrix(fk4noeframe.obstime))
# construct both precession matricies - if the equinoxes are B1950 and
# J2000, these are just identity matricies
pmat1 = fk5coord._precession_matrix(fk5coord.equinox, EQUINOX_J2000)
pmat2 = fk4noeframe._precession_matrix(EQUINOX_B1950, fk4noeframe.equinox)
return matrix_product(pmat2, B, pmat1)
def _ecliptic_to_icrs(from_coo, to_frame):
# first un-precess from ecliptic to ICRS orientation
rmat = _ecliptic_rotation_matrix()
intermed_repr = from_coo.cartesian.transform(matrix_transpose(rmat))
# now offset back to barycentric, which is the correct center for ICRS
# get barycentric sun coordinate
bary_sun_pos = get_body_barycentric("sun", from_coo.obstime)
newrepr = intermed_repr + bary_sun_pos
return to_frame.realize_frame(newrepr)
def fk5_to_fk4_no_e(fk5coord, fk4noeframe):
# Get transposed version of the rotating correction terms... so with the
# transpose this takes us from FK5/J200 to FK4/B1950
B = matrix_transpose(_fk4_B_matrix(fk4noeframe.obstime))
# construct both precession matricies - if the equinoxes are B1950 and
# J2000, these are just identity matricies
pmat1 = fk5coord._precession_matrix(fk5coord.equinox, EQUINOX_J2000)
pmat2 = fk4noeframe._precession_matrix(EQUINOX_B1950, fk4noeframe.equinox)
return matrix_product(pmat2, B, pmat1)
def ecliptic_to_iau76_icrs(from_coo, to_frame):
# first un-precess from ecliptic to ICRS orientation
rmat = _obliquity_only_rotation_matrix()
# now offset back to barycentric, which is the correct center for ICRS
# get barycentric sun coordinate
# this goes here to avoid circular import errors
from astropy.coordinates.solar_system import get_body_barycentric
bary_sun_pos = get_body_barycentric("sun", from_coo.obstime)
return matrix_transpose(rmat), bary_sun_pos
def precessedgeo_to_gcrs(from_coo, to_frame):
# first un-precess
pmat = gcrs_precession_mat(from_coo.equinox)
crepr = from_coo.cartesian.transform(matrix_transpose(pmat))
gcrs_coo = GCRS(crepr,
obstime=to_frame.obstime,
obsgeoloc=to_frame.obsgeoloc,
obsgeovel=to_frame.obsgeovel)
# then move to the GCRS that's actually desired
return gcrs_coo.transform_to(to_frame)
def hci_to_hgs(hcicoord, hgsframe):
"""
Convert from Heliocentric Inertial to Heliographic Stonyhurst
"""
# First transform the HCI coord to the HGS obstime
int_coord = _transform_obstime(hcicoord, hgsframe.obstime)
# Rotate from HCI to HGS
total_matrix = matrix_transpose(_rotation_matrix_hgs_to_hci(int_coord.obstime))
newrepr = int_coord.cartesian.transform(total_matrix)
return hgsframe._replicate(newrepr, obstime=int_coord.obstime)
def coord_to_referenceplane(from_coord, to_reference_plane):
"""Convert a sky coordinate to a reference-plane frame."""
if (to_reference_plane.origin is None
or not to_reference_plane.origin.has_data):
raise ValueError("Reference plane origin frame object must have "
"data, i.e. it must have a position specified.")
M, offset = referenceplane_to_coord(to_reference_plane, from_coord)
M = matrix_transpose(M)
offset = (-offset).transform(M)
return M, offset
def hgc_to_hgs(hgccoord, hgsframe):
"""
Convert from Heliographic Carrington to Heliographic Stonyhurst.
"""
# First transform the HGC coord to the HGS obstime
int_coord = _transform_obstime(hgccoord, hgsframe.obstime)
# Rotate from HGC to HGS
total_matrix = matrix_transpose(_rotation_matrix_hgs_to_hgc(int_coord.obstime))
newrepr = int_coord.cartesian.transform(total_matrix)
return hgsframe.realize_frame(newrepr)
def true_helioecliptic_to_icrs(from_coo, to_frame):
if not u.m.is_equivalent(from_coo.cartesian.x.unit):
raise UnitsError(_NEED_ORIGIN_HINT.format(from_coo.__class__.__name__))
# first un-precess from ecliptic to ICRS orientation
rmat = _true_ecliptic_rotation_matrix(from_coo.equinox)
# now offset back to barycentric, which is the correct center for ICRS
sun_from_ssb = get_offset_sun_from_barycenter(
from_coo.obstime, include_velocity=bool(from_coo.data.differentials))
return matrix_transpose(rmat), sun_from_ssb
def hee_to_hme(heecoord, hmeframe):
"""
Convert from Heliocentric Earth Ecliptic to Heliocentric Mean Ecliptic
"""
int_frame = HeliocentricMeanEcliptic(obstime=heecoord.obstime, equinox=heecoord.obstime)
# Rotate the HEE coord to the intermediate frame
total_matrix = matrix_transpose(_rotation_matrix_hme_to_hee(int_frame))
int_repr = heecoord.cartesian.transform(total_matrix)
int_coord = int_frame.realize_frame(int_repr)
# Convert to the HME frame through HCRS
return int_coord.transform_to(HCRS).transform_to(hmeframe)
def hgc_to_hgs(hgccoord, hgsframe):
"""
Convert from Heliographic Carrington to Heliographic Stonyhurst.
"""
_check_observer_defined(hgccoord)
# First transform the HGC coord to the HGS obstime
int_coord = _transform_obstime(hgccoord, hgsframe.obstime)
# Rotate from HGC to HGS
total_matrix = matrix_transpose(_rotation_matrix_hgs_to_hgc(int_coord.obstime,
hgccoord.observer.radius))
newrepr = int_coord.cartesian.transform(total_matrix)
return hgsframe._replicate(newrepr, obstime=int_coord.obstime)
def true_helioecliptic_to_icrs(from_coo, to_frame):
if not u.m.is_equivalent(from_coo.cartesian.x.unit):
raise UnitsError(_NEED_ORIGIN_HINT.format(from_coo.__class__.__name__))
# first un-precess from ecliptic to ICRS orientation
rmat = _true_ecliptic_rotation_matrix(from_coo.equinox)
# now offset back to barycentric, which is the correct center for ICRS
# this goes here to avoid circular import errors
from astropy.coordinates.solar_system import get_body_barycentric
# get barycentric sun coordinate
bary_sun_pos = get_body_barycentric('sun', from_coo.obstime)
return matrix_transpose(rmat), bary_sun_pos
def tete_to_gcrs(tete_coo, gcrs_frame):
# compute the pn matrix, and then multiply by its transpose
jd1, jd2 = get_jd12(tete_coo.obstime, 'tt')
# Classical NPB matrix, IAU 2006/2000A
# (same as in builtin_frames.utils.get_cip).
rbpn = erfa.pnm06a(jd1, jd2)
newrepr = tete_coo.cartesian.transform(matrix_transpose(rbpn))
gcrs = GCRS(newrepr,
obstime=tete_coo.obstime,
obsgeoloc=tete_coo.obsgeoloc,
obsgeovel=tete_coo.obsgeovel)
# now do any needed offsets (no-op if same obstime and 0 pos/vel)
return gcrs.transform_to(gcrs_frame)
def hci_to_hgs(hcicoord, hgsframe):
"""
Convert from Heliocentric Inertial to Heliographic Stonyhurst
"""
# First transform the HCI coord to the HGS obstime
int_coord = _transform_obstime(hcicoord, hgsframe.obstime)
if int_coord.obstime is None:
raise ConvertError("To perform this transformation, the coordinate"
" frame needs a specified `obstime`.")
# Rotate from HCI to HGS
total_matrix = matrix_transpose(_rotation_matrix_hgs_to_hci(int_coord.obstime))
newrepr = int_coord.cartesian.transform(total_matrix)
return hgsframe._replicate(newrepr, obstime=int_coord.obstime)
def helioecliptic_to_icrs(from_coo, to_frame):
if not u.m.is_equivalent(from_coo.cartesian.x.unit):
raise UnitsError(_NEED_ORIGIN_HINT.format(from_coo.__class__.__name__))
# first un-precess from ecliptic to ICRS orientation
rmat = _ecliptic_rotation_matrix(from_coo.equinox)
intermed_repr = from_coo.cartesian.transform(matrix_transpose(rmat))
# now offset back to barycentric, which is the correct center for ICRS
# this goes here to avoid circular import errors
from astropy.coordinates.solar_system import get_body_barycentric
# get barycentric sun coordinate
bary_sun_pos = get_body_barycentric('sun', from_coo.obstime)
newrepr = intermed_repr + bary_sun_pos
return to_frame.realize_frame(newrepr)
def get_matrix_vectors(galactocentric_frame, inverse=False):
"""
Use the ``inverse`` argument to get the inverse transformation, matrix and
offsets to go from Galactocentric to ICRS.
"""
# shorthand
gcf = galactocentric_frame
# rotation matrix to align x(ICRS) with the vector to the Galactic center
mat1 = rotation_matrix(-gcf.galcen_coord.dec, 'y')
mat2 = rotation_matrix(gcf.galcen_coord.ra, 'z')
# extra roll away from the Galactic x-z plane
mat0 = rotation_matrix(gcf.get_roll0() - gcf.roll, 'x')
# construct transformation matrix and use it
R = matrix_product(mat0, mat1, mat2)
# Now need to translate by Sun-Galactic center distance around x' and
# rotate about y' to account for tilt due to Sun's height above the plane
translation = r.CartesianRepresentation(gcf.galcen_distance * [1., 0., 0.])
z_d = gcf.z_sun / gcf.galcen_distance
H = rotation_matrix(-np.arcsin(z_d), 'y')
# compute total matrices
A = matrix_product(H, R)
# Now we re-align the translation vector to account for the Sun's height
# above the midplane
offset = -translation.transform(H)
if inverse:
# the inverse of a rotation matrix is a transpose, which is much faster
# and more stable to compute
A = matrix_transpose(A)
offset = (-offset).transform(A)
offset_v = r.CartesianDifferential.from_cartesian(
(-gcf.galcen_v_sun).to_cartesian().transform(A))
offset = offset.with_differentials(offset_v)
else:
offset = offset.with_differentials(gcf.galcen_v_sun)
return A, offset
def sgr_to_galactic():
""" Compute the transformation from heliocentric Sagittarius coordinates to
spherical Galactic.
"""
return matrix_transpose(galactic_to_sgr())
def oph_to_gal():
""" Compute the transformation from heliocentric Ophiuchus coordinates to
spherical Galactic.
"""
return matrix_transpose(gal_to_oph())
def oph_to_galactic():
""" Compute the transformation from heliocentric Orphan coordinates to
spherical Galactic.
"""
return matrix_transpose(galactic_to_orp())
def gd1_to_icrs():
""" Compute the transformation from heliocentric GD1 coordinates to
spherical Galactic.
"""
return matrix_transpose(icrs_to_gd1())
def pal5_to_icrs():
""" Compute the transformation from heliocentric Pal 5 coordinates to
spherical Galactic.
"""
return matrix_transpose(icrs_to_pal5())
def hgs_to_hcrs(hgscoord, hcrsframe):
"""
Convert from Heliographic Stonyhurst to HCRS.
"""
return matrix_transpose(hcrs_to_hgs(hcrsframe, hgscoord))
def geosolarecliptic_to_gcrs(from_coo, gcrs_frame):
return matrix_transpose(gcrs_to_geosolarecliptic(gcrs_frame, from_coo))
def mag_to_gal():
return matrix_transpose(gal_to_mag())
def _gal_to_fk5(galcoord, fk5frame):
return matrix_transpose(fk5_to_gal(fk5frame, galcoord))
def gal_to_fk4(galcoords, fk4frame):
return matrix_transpose(fk4_to_gal(fk4frame, galcoords))
def supergal_to_gal():
return matrix_transpose(gal_to_supergal())
def sgr_to_galactic():
""" Compute the transformation matrix from heliocentric Sgr coordinates to
spherical Galactic.
"""
return matrix_transpose(SGR_MATRIX)
def baryecliptic_to_icrs(from_coo, to_frame):
return matrix_transpose(icrs_to_baryecliptic(to_frame, from_coo))
def gd1_to_icrs():
""" Compute the transformation from heliocentric Jhelum coordinates to
spherical ICRS.
"""
return matrix_transpose(icrs_to_jhelum())
