pyimcom.wcsutil

This file contains the PyIMCOM_WCS class, which allows PyIMCOM to take in a WCS either as a FITS header or a GWCS from an ASDF file.

PyIMCOM_WCS supports the all_pix2world and all_world2pix methods, which are like their astropy counterparts. A separate local_partial_pixel_derivatives2 function was written so that we don’t need to rely on astropy’s partial derivative function (which has singular behavior near the poles).

Classes

ABasis: Base class for basis polynomials.
SimpleBaiss: Simple polynomials.
LocWCS: Internal version of gwcs plus approximations.
PyIMCOM_WCS: Main class for PyIMCOM’s WCS, intended to support functions in PyIMCOM that were originally written with astropy.wcs.WCS but now also have to accept gwcs inputs.

Functions

local_partial_pixel_derivatives2: Jacobian for WCS (2-sided derivative, designed to also work near poles).
get_pix_area: Calculate the effective pixel areas in the image.
_stand_alone_test: Unit test function.

Classes

`ABasis`	Base class for 2D basis polynomials. These are defined in the range -1<u<1 and -1<v<1.
`SimpleBasis`	Simple polynomials (each coefficient is 1). Base class is pyimcom.wcsutil.ABasis.
`LocWCS`	WCS built from a gwcs that can be reported in various formats.
`PyIMCOM_WCS`	Class that has the key methods we depend on from astropy.wcs,

Functions

`local_partial_pixel_derivatives2`(inwcs, x, y)	Alternative form of the local partial derivatives function
`get_pix_area`(inwcs[, region, pad, ovsamp])	Calculate the effective pixel areas in the image.
`_stand_alone_test`(infile)	Simple tests of the above routines.

Module Contents

class ABasis(p_order, N)[source]

Base class for 2D basis polynomials. These are defined in the range -1<u<1 and -1<v<1.

Want to use inherited classes that replace the coef_setup method.

Parameters:

p_order (int) – Max order of the polynomial.
N (int) – Side length of grid the polynomial is evaluated on.

N_basis[source]

Number of basis modes.

Type:: int

coefs[source]

Coefficient matrix: coefs[i,j,k] is the coefficient of u^i v^j in the kth polynomial.

Type:: np.array

eval()[source]: evaluation of polynomials

p_order[source]

N[source]

N_basis[source]

coefs[source]

coef_setup()[source]

Build the coefficients.

Shouldn’t get here, always use the methods from the inherited classes.

eval(u, v)[source]

Takes in an array of positions, and returns an array of the basis polynomials evaluated at those points.

Parameters:

u (np.array) – Array of horizontal positions. Shape (npts,).
v (np.array) – Array of vertical positions. Shape (npts,).

Returns:

A 2D array: out[k,l] = kth poly evaluated at lth point. Shape (N_basis, npts).

Return type:

np.array

Notes

Could be replaced with a more stable version for specific types of polynomials if provided by that basis.

class SimpleBasis(p_order, N)[source]

Bases: ABasis

Simple polynomials (each coefficient is 1). Base class is pyimcom.wcsutil.ABasis.

coef_setup()[source]: Build the coefficients.

class LocWCS(gwcs, N=4088)[source]

WCS built from a gwcs that can be reported in various formats.

Parameters:

gwcs (gwcs.WCS) – The generalized WCS.
N (int, optional) – Side length of the array.

gwcs[source]

The generalized WCS. (Same as gwcs.)

Type:: gwcs.WCS

N[source]

Side length of the array. (Same as N.)

Type:: int

ra_ctr[source]

Right ascension of projection center.

Type:: float

dec_ctr[source]

Declination of projection center.

Type:: float

uEast[source]

3-component unit vector pointing East.

Type:: np.array

uNorth[source]

3-component unit vector pointing North.

Type:: np.array

J[source]

2x2 Jacobian from detector to tangent plane coordinates in radians.

Type:: np.array

approx_wcs

The best-fit TAN-SIP approximation (if set).

Type:: astropy.wcs.WCS

wcs_max_err

The worst error (in pixels) from the approx_wcs (if set).

Type:: float

errmap

The error map (in pixels) from the approx_wcs (if set). Shape (2, N, N).

Type:: np.array

__init__()[source]: Constructor.

wcs_approx_sip()[source]: Build approximate TAN-SIP WCS.

_make_errmap()[source]: Build the error map.

err_interp()[source]: Makes error map interpolator for the TAN-SIP approximation.

gwcs[source]

N = 4088[source]

ra_ctr[source]

dec_ctr[source]

uEast[source]

uNorth[source]

J[source]

wcs_approx_sip(p_order=3, nq=100, basis='simple', verbose=False)[source]

Generate approximate TAN-SIP polynomial wcs.

Parameters:

p_order (int, optional) – Order of polynomial to fit.
nq (int, optional) – Grid size for fitting WCS (nq x nq).
basis (str, optional) – Type of basis to use in fitting the WCS.
verbose (bool) – Print lots of diagnostics to the terminal.

Notes

The following basis sets for the linear algerbra are available:

‘simple’ : simple polynomials (could be unstable for high order)

_make_errmap()[source]

Builds the error map.

Notes

The shape of the error map is (2, N, N).

The format is:

errmap[0,j,i] is the x-offset of pixel (i,j)
errmap[1,j,i] is the y-offset.

The offset is in the sense of if there is a barred coordinate system that is the TAN-SIP approximation and unbarred is the true system, then:

# xbar == x + errmap[0,y,x]
# ybar == y + errmap[1,y,x]

err_interp(a=4, n_pad=2048)[source]

Makes interpolators for the delta x = xbar-x and delta y = ybar-y directions.

The functions returned are of the form dX(arr), where arr is an array of shape (K,2) indicating K points. arr[:,0] are the y-values, and arr[:,1] are the x-values.

Parameters:

a (int) – Number of pixels from edge to use for linear extrapolation..
n_pad (int) – Distance to extrapolate the error map.

Returns:

function – An interpolator function for the delta x error.
function – An interpolator function for the delta y error.

class PyIMCOM_WCS(inwcs, noconvert=False)[source]

Class that has the key methods we depend on from astropy.wcs, but can be constructed from other types of WCS information (including gwcs).

Parameters:

inwcs (fits.Header or astropy.wcs.WCS or gwcs.wcs.WCS) – The input WCS.
noconvert (bool, optional) – Do not internally convert WCS type.

__init__()[source]: Constructor.

all_pix2world()[source]: pixel -> world coordinates (astropy-like)

all_world2pix()[source]: world -> pixel coordinates (astropy-like)

constructortype

What type of input was used to make this object.

Type:: str

type

What type of method to use in computation (currently ASTROPY or GWCS).

Type:: str

obj

The WCS object being wrapped.

Type:: variable

err

For ‘ASTROPY+’, contains an interpolator for the error. Not used for other types.

Type:: (function,function), optional

array_shape[source]

_all_pix2world(pos, origin)[source]

An astropy-like function to go from pixel to world coordinates.

Parameters:

pos (np.array) – Pixel coordinates, shape (N,2).
origin (int) – Offset of lower-left pixel, should be 0 or 1.

Returns:

World coordinates. Shape (N,2).

Return type:

np.array

all_pix2world(*args)[source]

An astropy-like function to go from pixel to world coordinates.

This has both a 2-argument (pos, origin) or a 3-argument (pos, pos2, origin) format.

In 2-argument format, pos is a shape (N, 2) array and the return is also a shape (N, 2) array.

In 3-argument format, pos is a shape (N,) array of pixel x, pos2 is a shape (N,) array of pixel y, and the return valus is ra, dec, both shape (N,) arrays. For N=1, you may use scalars.

In both cases, origin is an integer indicating the index of the lower-left pixel (0 or 1).

Parameters:: *args (variable) – See description.
Returns:: World coordinates.
Return type:: np.array or np.array, np.array