pixelfunc – Pixelisation related functions

conversion from/to sky coordinates

pix2ang(nside, ipix[, nest, lonlat])	pix2ang : nside,ipix,nest=False,lonlat=False -> theta[rad],phi[rad] (default RING)
pix2vec(nside, ipix[, nest])	pix2vec : nside,ipix,nest=False -> x,y,z (default RING)
ang2pix(nside, theta, phi[, nest, lonlat, ...])	ang2pix : nside,theta[rad],phi[rad],nest=False,lonlat=False,latauto=False,latbounce=True -> ipix (default:RING)
vec2pix(nside, x, y, z[, nest])	vec2pix : nside,x,y,z,nest=False -> ipix (default:RING)
vec2ang(vectors[, lonlat])	vec2ang: vectors [x, y, z] -> theta[rad], phi[rad].
ang2vec(theta, phi[, lonlat])	ang2vec : convert angles to 3D position vector.
xyf2pix(nside, x, y, face[, nest])	xyf2pix : nside,x,y,face,nest=False -> ipix (default:RING)
pix2xyf(nside, ipix[, nest])	pix2xyf : nside,ipix,nest=False -> x,y,face (default RING)
get_all_neighbours(nside, theta[, phi, ...])	Return the 8 nearest pixels.
get_interp_weights(nside, theta[, phi, ...])	Return the 4 closest pixels on the two rings above and below the location and corresponding weights.
get_interp_val(m, theta, phi[, nest, lonlat])	Return the bi-linear interpolation value of map(s) using 4 nearest neighbours.

conversion between NESTED and RING schemes

nest2ring(nside, ipix)	Convert pixel number from NESTED ordering to RING ordering.
ring2nest(nside, ipix)	Convert pixel number from RING ordering to NESTED ordering.
reorder(map_in[, inp, out, r2n, n2r])	Reorder a HEALPix map from RING/NESTED ordering to NESTED/RING.

nside/npix/resolution

nside2npix(nside)	Give the number of pixels for the given nside.
npix2nside(npix)	Give the nside parameter for the given number of pixels.
nside2order(nside)	Give the resolution order for a given nside.
order2nside(order)	Give the nside parameter for the given resolution order.
npix2order(npix)	Give the resolution order for the given number of pixels.
order2npix(order)	Give the number of pixels for the given resolution order.
nside2resol(nside[, arcmin])	Give approximate resolution (pixel size in radian or arcmin) for nside.
nside2pixarea(nside[, degrees])	Give pixel area given nside in square radians or square degrees.
max_pixrad(nside[, degrees])	Maximum angular distance between any pixel center and its corners.
isnsideok(nside[, nest])	Returns True if nside is a valid nside parameter, False otherwise.
isnpixok(npix)	Return True if npix is a valid value for HEALPix map size, False otherwise.
get_map_size(m)	Returns the npix of a given map (implicit or explicit pixelization).
get_min_valid_nside(npix)	Returns the minimum acceptable nside so that npix <= nside2npix(nside).
get_nside(m)	Return the nside of the given map.
maptype(m)	Describe the type of the map (valid, single, sequence of maps).
ud_grade(map_in, nside_out[, pess, ...])	Upgrade or degrade resolution of a map (or list of maps).

Notes on downgrade quality

For simple resolution changes, ud_grade() remains available and fast. It is usually the right choice for masks, hit-count maps, and compact pixel-localized features. For diffuse or band-limited downgrade workflows, healpy.sphtfunc.harmonic_ud_grade() can preserve the map more faithfully because it first band-limits the map in spherical-harmonic space before synthesizing it at the target nside.

See healpy.sphtfunc.harmonic_ud_grade() for the API and the following tutorial notebooks for worked comparisons:

• harmonic_ud_grade vs ud_grade: A Focused Comparison

Masking pixels

UNSEEN	Special value used for masked pixels
mask_bad(m[, badval, rtol, atol])	Returns a bool array with True where m is close to badval.
mask_good(m[, badval, rtol, atol])	Returns a bool array with False where m is close to badval.
ma(m[, badval, rtol, atol, copy])	Return map as a masked array, with badval pixels masked.

Map data manipulation

fit_dipole(m[, nest, bad, gal_cut])	Fit a dipole and a monopole to the map, excluding bad pixels.
fit_monopole(m[, nest, bad, gal_cut])	Fit a monopole to the map, excluding unseen pixels.
remove_dipole(m[, nest, bad, gal_cut, ...])	Fit and subtract the dipole and the monopole from the given map m.
remove_monopole(m[, nest, bad, gal_cut, ...])	Fit and subtract the monopole from the given map m.