Image Processing

Core functionality for astronomical image alignment, combination, and calibration using the drizzle algorithm. This provides the primary interface for processing Hubble Space Telescope observations with cosmic ray removal, distortion correction, and optimal image combination.

Capabilities

AstroDrizzle - Primary Image Processing

Automates the alignment, cosmic ray removal, distortion correction, and combination of HST images. AstroDrizzle is the main task for most DrizzlePac workflows, providing both interactive and pipeline processing modes.

def AstroDrizzle(input=None, mdriztab=False, editpars=False,
                configobj=None, wcsmap=None, **input_dict):
    """
    Main command-line interface for AstroDrizzle processing.

    Parameters:
    - input: str or list, input images or association table
    - mdriztab: bool, use MDRIZTAB for parameters
    - editpars: bool, allow interactive parameter editing
    - configobj: ConfigObj, configuration object with parameters
    - wcsmap: function, custom WCS mapping function
    - **input_dict: dict, parameter overrides

    Returns:
    None (creates output files)
    """

def run(configobj, wcsmap=None, input_dict=None):
    """
    Core processing function for AstroDrizzle.

    Parameters:
    - configobj: ConfigObj, configuration with all processing parameters
    - wcsmap: function, optional custom WCS transformation function
    - input_dict: dict, optional parameter overrides

    Returns:
    None (creates output files)
    """

Usage Example

from drizzlepac import astrodrizzle

# Basic usage with default parameters
astrodrizzle.AstroDrizzle('j8bt06nyq_flt.fits,j8bt06nzq_flt.fits',
                         output='combined',
                         clean=True,
                         driz_separate=True,
                         driz_sep_wcs=True,
                         median=True,
                         blot=True,
                         driz_cr=True,
                         driz_combine=True)

# Using configuration object for complex processing
from drizzlepac import util
configobj = util.build_configobj('astrodrizzle.cfg')
astrodrizzle.run(configobj)

Multi-Drizzle Interface

Legacy MultiDrizzle interface provided for backward compatibility.

def main():
    """
    Command-line entry point for mdriz script.

    Returns:
    None
    """

Pipeline Processing

Automated pipeline processing interface for batch operations and systematic data reduction.

def process(inFile, force=False, newpath=None, num_cores=None,
           inmemory=True, **kwargs):
    """
    Main processing function for pipeline operations.

    Parameters:
    - inFile: str, input association file or observation list
    - force: bool, force reprocessing of existing outputs
    - newpath: str, output directory path
    - num_cores: int, number of CPU cores to use
    - inmemory: bool, perform processing in memory when possible
    - **kwargs: dict, additional processing parameters

    Returns:
    bool, success status
    """

def run_driz(inlist, trlfile, calfiles, mode='default-pipeline', **kwargs):
    """
    Core drizzling function for pipeline mode.

    Parameters:
    - inlist: list, input file list
    - trlfile: str, trailer file name for logging
    - calfiles: list, calibrated input files
    - mode: str, processing mode ('default-pipeline', 'hap', etc.)
    - **kwargs: dict, processing parameters

    Returns:
    list, output file names
    """

Processing Modes

Standard AstroDrizzle Processing

Default processing with full cosmic ray removal and image combination:

1. Separate Drizzling - Individual exposure processing with distortion correction
2. Median Creation - Statistical combination for cosmic ray identification
3. Blotting - Transformation of median back to original image geometry
4. Cosmic Ray Detection - Identification and flagging of cosmic ray pixels
5. Final Drizzling - Combination of cleaned images into final product

Pipeline Processing

Automated processing optimized for large datasets:

• Minimal user interaction required
• Standardized parameter sets
• Batch processing capabilities
• Quality assessment integration

HAP Processing

Hubble Advanced Products processing with enhanced algorithms:

• Advanced astrometric solutions
• Multi-visit processing
• Automated quality control
• Standardized product formats

Key Processing Parameters

Geometric Parameters

• output: Output image root name
• outnx/outny: Output image dimensions
• rot: Rotation angle for output WCS
• scale: Output pixel scale
• ra/dec: Output image center coordinates

Cosmic Ray Parameters

• driz_cr: Enable cosmic ray detection
• driz_cr_corr: Correlation threshold
• driz_cr_snr: Signal-to-noise ratio thresholds
• driz_cr_grow: Pixel growth radius around detected CRs

Drizzling Parameters

• pixfrac: Linear size of drop in input pixels
• kernel: Drizzling kernel ('turbo', 'square', 'lanczos3')
• fillval: Value for output pixels with no input

Quality Control

• clean: Remove intermediate files after processing
• in_memory: Perform processing in memory
• num_cores: Parallel processing configuration

Output Products

AstroDrizzle creates several output files:

• _drz.fits: Final combined image
• _wht.fits: Weight map showing coverage
• _ctx.fits: Context image showing input contributions
• _sci.fits: Science extension from combined image
• _err.fits: Error extension from combined image

Error Handling

Common error conditions and exceptions:

• IOError: Invalid input files or missing calibration references
• ValueError: Incompatible WCS solutions or parameter conflicts
• MemoryError: Insufficient memory for large image processing
• RuntimeError: Convergence failures in alignment or cosmic ray detection

Processing continues with warnings for non-critical errors, with full error details logged to trailer files (.tra).