autowisp.image_smoothing module — AutoWISP documentation

# autowisp.image_smoothing module

## Class Inheritance Diagram

Define classes for smoothing images.

class autowisp.image_smoothing.ChainSmoother(*smoothers, **kwargs)

  Bases: `ImageSmoother`

  Combine more than one smoothers, each is applied sequentially.

  Works much like a list of smoothers, except it adds smooth and detrend methods.

  smoothing_chain

    The current list of smoothers and the order in which they are applied. The first will be applied to the input image, the second will be applied to the result of the first etc.

  __delitem__(position)

    Delete smoothe at position.

  __init__(*smoothers, **kwargs)

    Create a chain combining the given smoothers in the given order.

    Parameters:

      - smoothers – A list of the image smoothers to combine.

      - kwargs – Any arguments to pass to parent constructor.

  __setitem__(position, smoother)

    Replace the smoother at position.

  _apply_smoothing(image)

    Smooth the given image using the current chain of smoothers.

  append(smoother)

    Add a new smoother to the end of the sequence.

  clear()

    Like list clear.

  extend(smoothers)

    Add multiple smoothers to the end of the chain.

  insert(position, smoother)

    Like list insert.

  pop(position=-1)

    Like list pop.

  remove(smoother)

    Like list remove.

class autowisp.image_smoothing.ImageSmoother(**kwargs)

  Bases: `ABC`

  Define the interface for applying smoothing algorithms to images.

  bin_factor

    See same name argument to `smooth()`.

  zoom_interp_order

    See same name argument to `smooth()`.

  __init__(**kwargs)

    Set default pre-shrink/post-zoom bin factor and interpolation order.

    Parameters:

      kwargs – All arguments except bin_factor, interp_order and padding mode(see `smooth()`) are ignored.

    Returns:

      None

  abstractmethod _apply_smoothing(image, **kwargs)

    Return a smooth version of the given image (no pre-shrinking).

    Parameters:

      - image – The image to smooth.

      - kwargs – Any arguments configuring how smoothing is to be performed.

    Returns:

      The smoothed version of the image per the currently defined smoothing.

    Return type:

      2-D array

  detrend(image, **kwargs)

    De-trend the input image by its smooth version (see smooth).

  smooth(image, *, bin_factor=None, zoom_interp_order=None, padding_mode='reflect', **kwargs)

    Sandwich smoothing between initial binning and final zoom.

    Parameters:

      - image – The image to smooth.

      - bin_factor – The factor to pre-bin the image by (see `autowisp.image_utilities.bin_image()` for details). After smoothing the image is zoomed by the same factor to recover the original size. If None, the value defined at construction is used, otherwise this value appliesfor this image only.

      - interp_order – The interpolation order to use when zooming the image at the end. If None, the interpolation order defined at construction is used, otherwise this value applies for this image only.

      - padding_mode – How to pad the image to have an integer number of bins, if pre-binning and post-zooming is used.

      - kwargs – Any arguments configuring how smoothing is to be performed.

    Returns:

      The smoothed version of the image.

    Return type:

      2-D array

class autowisp.image_smoothing.PolynomialImageSmoother(*, num_x_terms=None, num_y_terms=None, outlier_threshold=None, max_iterations=None, **kwargs)

  Bases: `SeparableLinearImageSmoother`

  Smooth image is modeled as a polynomial in x times another polynomial in y.

  static _get_powerlaw_pixel_integrals(power, resolution)

    Return the integrals over one pixel dimension of x^power for each pixel.

    Parameters:

      - power – The power of the corresponding coordinate of the term we are integrating.

      - resolution – The resolution of the image in the dimension in which to calculate the pixel integrlas.

    Returns:

      An array with the i-th entry being the integral of the scaled x coordinate to the given power over each pixel.

    Return type:

      1-D array

  static get_x_pixel_integrals(power, resolution)

    Return the integrals over one pixel dimension of x^power for each pixel.

    Parameters:

      - power – The power of the corresponding coordinate of the term we are integrating.

      - resolution – The resolution of the image in the dimension in which to calculate the pixel integrlas.

    Returns:

      An array with the i-th entry being the integral of the scaled x coordinate to the given power over each pixel.

    Return type:

      1-D array

  static get_y_pixel_integrals(power, resolution)

    Return the integrals over one pixel dimension of x^power for each pixel.

    Parameters:

      - power – The power of the corresponding coordinate of the term we are integrating.

      - resolution – The resolution of the image in the dimension in which to calculate the pixel integrlas.

    Returns:

      An array with the i-th entry being the integral of the scaled x coordinate to the given power over each pixel.

    Return type:

      1-D array

class autowisp.image_smoothing.SeparableLinearImageSmoother(*, num_x_terms=None, num_y_terms=None, outlier_threshold=None, max_iterations=None, **kwargs)

  Bases: `ImageSmoother`

  Handle smoothing function = product of linear functions in each dimension.

  In more detail this is a base class that perform smoothing with a smoothing function consisting of the product of separate smoothing functions in x and y, each of which predicts pixel values as a linear combination of some parameters.

  num_x_terms

    The number of terms in the smoothing function in the x direction.

  num_y_terms

    The number of terms in the smoothing function in the y direction.

  __init__(*, num_x_terms=None, num_y_terms=None, outlier_threshold=None, max_iterations=None, **kwargs)

    Define the default smoothing configuration (overwritable on use).

    Parameters:

      - num_x_terms – See same name argument to `_apply_smoothing()` .

      - num_y_terms – See same name argument to `_apply_smoothing()`.

      - outlier_threshold – See same name argument to `_apply_smoothing()`.

      - max_iterations – See same name argument to `_apply_smoothing()`.

      - kwargs – Any arguments to pass to parent’s `__init__`.

    Returns:

      None

  _apply_smoothing(image, *, num_x_terms=None, num_y_terms=None, outlier_threshold=None, max_iterations=None)

    Return a smooth version of the given image.

    Parameters:

      - image – The image to smooth.

      - num_x_terms – The number of parameters of the x smoothing function.

      - num_y_terms – The number of parameters of the y smoothing function.

      - outlier_threshold – The threshold for discarding pixel values as being outliers. See same name argument to `autowisp.iterative_rejection_util.iterative_rej_linear_leastsq()` .

      - max_iterations – The maximum number of reject/re-fit iterations allowed. See same name argument to `autowisp.iterative_rejection_util.iterative_rej_linear_leastsq()` .

    Returns:

      2-D array:

        The best approximation of the input image possible with the smoothing function.

      float:

        The root mean square residual returned by `autowisp.iterative_rejection_util.iterative_rej_linear_leastsq()` .

    Return type:

      (tuple)

  _get_smoothing_matrix(num_x_terms, num_y_terms, y_resolution, x_resolution)

    Return matrix giving flattened smooth image when applied to fit params.

    Parameters:

      - num_x_terms – See same name argument to `_apply_smoothing()`.

      - num_y_terms – See same name argument to `_apply_smoothing()`.

      - x_resolution – The number of image columns.

      - y_resolution – The number of image rows.

    Returns:

      An (x_res * y_res) by (num_x_terms * num_y_terms) matrix which when applied to a set of parameters returns the value of each image pixel per the smoothing function.

    Return type:

      2-D array

  abstractmethod get_x_pixel_integrals(param_ind, x_resolution)

    Return the x smoothing func. integral over pixels for 1 nonzero param.

    Parameters:

      - param_ind – The index of the input parameter which is non-zero.

      - x_resolution – The resolution of the input image in the x direction.

    Returns:

      Array with length equal to the x-resolution of the image with the i-th entry being the integral of the x part of the smoothing function over the i-th pixel.

    Return type:

      1-D array

  abstractmethod get_y_pixel_integrals(param_ind, y_resolution)

    See get_x_pixel_integrals.

class autowisp.image_smoothing.SplineImageSmoother(*, num_x_nodes=None, num_y_nodes=None, spline_degree=3, **kwargs)

  Bases: `SeparableLinearImageSmoother`

  Smooth image is modeled as a product of cubic splines in x and y.

  __init__(*, num_x_nodes=None, num_y_nodes=None, spline_degree=3, **kwargs)

    Set-up spline interpolation with the given number of nodes.

    Parameters:

      - num_x_nodes – The number of spline nodes for the x spline.

      - num_y_nodes – The number of spline nodes for the y spline.

      - kwargs – Forwarded directly to `SeparableLinearImageSmoother.__init__()`, along with num_x_terms = num_x_nodes and num_y_terms = num_y_nodes.

    Returns:

      None

  _apply_smoothing(image, *, num_x_nodes=None, num_y_nodes=None, **kwargs)

    Handle change in interpolation nodes needed by integrals functions.

    Parameters:

      () – See `SeparableLinearImageSmoother._apply_smoothing()` except the names of num_x_terms and num_y_terms have been changed to num_x_nodes and num_y_nodes respectively.

    Returns:

      None

  static get_spline_pixel_integrals(node_index, resolution, num_nodes, spline_degree)

    Return the integrals over one pixel dimension of a basis spline.

    The spline basis functions are defined as an interpolating spline (i.e. no smoothing) over y values that are one for the node_index-th node and zero everywhere else.

    Parameters:

      - node_index – The node at which the spline should evaluate to one. All other nodes get a value of zero.

      - resolution – The resolution of the image in the dimension in which to calculate the pixel integrlas.

      - num_nodes – The number of nodes in the spline. The image is scaled to have a dimension of (num_nodes - 1) and nodes are set at integer values.

      - spline_degree – The degree of the spline to use.

    Returns:

      An array with the i-th entry being the integral of the spline over the i-th pixel.

    Return type:

      1-D array

  get_x_pixel_integrals(param_ind, x_resolution)

    Return integrals of the param_ind-th x direction spline basis function.

    Parameters:

      () – See `SeparableLinearImageSmoother.get_x_pixel_integrals()`.

    Returns:

      See `SeparableLinearImageSmoother.get_x_pixel_integrals()`.

  get_y_pixel_integrals(param_ind, y_resolution)

    Return integrals of the param_ind-th y direction spline basis function.

    Parameters:

      () – See `SeparableLinearImageSmoother.get_y_pixel_integrals()`.

    Returns:

      See `SeparableLinearImageSmoother.get_y_pixel_integrals()`.

class autowisp.image_smoothing.WrapFilterAsSmoother(smoothing_filter, *, bin_factor=None, zoom_interp_order=None, **filter_config)

  Bases: `ImageSmoother`

  Wrap one of the numpy or astropy image filters in a smoother.

  __init__(smoothing_filter, *, bin_factor=None, zoom_interp_order=None, **filter_config)

    Apply the given filter through the ImageSmoother interface.

    Parameters:

      - smoothing_filter – The filter to apply to smooth images.

      - bin_factor – See `ImageSmoother.smooth()`.

      - zoom_interp_order – See `ImageSmoother.smooth()`.

      - filter_config – Any arguments to pass to the filter when applying, unless overwritten by arguments to `smooth()` or `detrend()`.

    Returns:

      None

  _apply_smoothing(image, **kwargs)

    Smooth the given image with the filter supplied on construction.

    Parameters:

      - image – The image to smooth.

      - kwargs – Additional or replacement arguments to pass to the filter when applying.