Image¶

(H_target, W_target) — the shape of the reprojected image you want. Usually this is the shape of the reference image you are aligning onto.

Forward transform on the target WCS. Signature::

target_pixel_to_world(x, y) -> tuple of ndarray

where x and y are 2-D ndarrays of target pixel coordinates (integer = pixel center) and the return is a tuple of world-coordinate arrays (for example (ra, dec)). astropy.wcs.WCS.pixel_to_world_values and the equivalent gwcs API match this signature.

Inverse transform on the source WCS. Signature::

source_world_to_pixel(*world_arrays) -> (x_source, y_source)

where the inputs are the world arrays produced by target_pixel_to_world and the return is the pair of 2-D ndarrays giving source-image pixel coordinates. astropy.wcs.WCS.world_to_pixel_values matches this signature.

Any 2-element sequence of positive ints — tuple, list, or ndarray are all accepted. If given as (step_h, step_w), evaluate the WCS callables on a coarse subgrid stepping every step_h rows and step_w columns of the target pixel grid, then bicubic-interpolate the result to the full (H_target + 1, W_target + 1) corner grid. Useful when the callables are expensive (notably JWST gwcs pipelines that solve a numerical inverse per evaluation): a 2048x2048 target with coarse_step=(64, 64) reduces the WCS call count from ~4M to ~1k. Both components must be positive and must divide their corresponding target_shape axis exactly; otherwise ValueError is raised. Default None evaluates the callables on the full corner grid (no interpolation).

pixel_corners of shape (H_target + 1, W_target + 1, 2) and dtype float64. The last axis is (x_source, y_source). Pass it directly to reproject_exact.

Input image of shape (H_in, W_in), dtype float32 or float64. NaN values are treated as masked input pixels: they are excluded from the numerator and from the valid weight, but they still count toward the geometric footprint.

Corner field of shape (H_out + 1, W_out + 1, 2), dtype float64. The last dimension stores [x_in, y_in] — the location of each output-pixel corner in the input image's continuous pixel coordinates, using the astropy convention that integer (x, y) is the center of pixel (row=y, column=x). Adjacent output pixels share corners by construction, which makes the partition watertight. NaN corners propagate to (NaN, 0, 0) in the output for any output pixel that touches them.

1-sigma error image, same shape and dtype as image. Default None. When given, the result's error attribute is a propagated 1-sigma map; when None it is None. Supplying it does not change image, footprint, or weight.

A frozen result object whose image, footprint, and weight attributes are each (H_out, W_out) arrays of dtype float64, plus an error attribute (None when no error input was given).

• image is the surface-brightness-conserving reprojection: sum(A_ij * image[i, j]) / sum(A_ij_valid) over the input pixels overlapping each output pixel, where A_ij is the polygon-intersection area in input-pixel units and the _valid sum excludes NaN input pixels. Output pixels with no valid contribution are NaN.
• footprint is the pure geometric overlap fraction in [0, 1]: how much of the output pixel falls inside the input image's pixel grid, independent of whether the covered pixels are NaN. Useful to distinguish "no data because we are outside the input footprint" from "no data because the inputs were masked".
• weight is the same numerator restricted to non-NaN input pixels, also in [0, 1]. Invariant: weight <= footprint; they are equal when no input pixel inside the overlap was NaN. The ratio weight / footprint (where footprint > 0) is the fraction of the covered region that was free of NaN.
• error is the propagated 1-sigma error, or None when no error input was supplied. Independent first-order propagation: sqrt(sum(A_ij^2 * sigma_ij^2)) / sum(A_ij) over the valid input pixels. An output pixel is NaN where it has no valid contribution, or where a contributing pixel had a valid value but a non-finite or negative error (the value still enters image, so its unknown variance cannot be dropped). Only the marginal per-pixel 1-sigma is given; correlations between output pixels sharing input pixels are not represented.

If image is not a 2-D float32 / float64 array, if pixel_corners is not a float64 array with last dimension 2 and both grid dimensions at least 2, or if error is given with a dtype other than image's or a shape other than image's.

2-D image, dtype float32 or float64. NaN / +-inf are treated as missing.

2-D PSF with odd dimensions, same dtype as image.

The convolved image, same shape and dtype as image.

If image is not a 2-D float32 / float64 array, psf dtype does not match image, or psf does not have odd dimensions.

2-D image, dtype float32 or float64.

Gaussian sigma in pixels along axis. Must be positive.

0 correlates down each column, 1 along each row. Default 0.

Kernel normalization. Default "l2" (matched-filter optimal).

Out-of-bounds handling, used only when renormalize=False. Default "zero".

When True, use NaN-as-missing renormalization (out-of-bounds is missing and boundary is ignored). Default False.

The filtered image, same shape and dtype as image.

If image is not a 2-D float32 / float64 array, sigma is not positive, axis is not 0 or 1, or normalization / boundary is invalid.

Rough cutout of any shape (rows, cols), dtype float32 or float64. Determines the dtype channel; error must match. Non-finite values are excluded from the centroid and marked invalid.

Edge length of the square output stamp. Must be odd.

1-sigma error, same shape and dtype as cutout. Default None (error-level equal weighting downstream).

True marks an invalid (excluded) pixel -- the noobase-wide polarity. Same shape as cutout. Default None.

FWHM (pixels) of the Gaussian centroid window. Default 3.0.

Centroid iteration cap. Default 10.

Centroid convergence tolerance (pixels). Default 1e-3.

None when no usable stamp can be produced (the odd window cannot fit fully inside the cutout, or there are too few valid pixels to centroid) -- an algorithmic skip, not an error. The caller filters these out before stacking.

If stamp_size is even, if stamp_size exceeds a cutout dimension, if error / mask shape does not equal the cutout shape, or if an array has an unsupported dtype.