drizzle 1.15.0__cp310-cp310-win32.whl

drizzle/__init__.py

@@ -0,0 +1,11 @@
+"""
+A package for combining dithered images into a single image
+"""
+from importlib.metadata import PackageNotFoundError, version
+
+
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = 'unknown'

drizzle/calc_pixmap.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+
+def calc_pixmap(first_wcs, second_wcs):
+    """
+    Calculate a mapping between the pixels of two images.
+
+    Parameters
+    ----------
+
+    first_wcs : wcs
+        A WCS object representing the coordinate system you are
+        converting from
+
+    seond_wcs : wcs
+        A WCS object representing the coordinate system you are
+        converting to
+
+    Returns
+    -------
+
+    A three dimensional array representing the transformation between
+    the two. The last dimension is of length two and contains the x and
+    y coordinates of a pixel center, repectively. The other two coordinates
+    correspond to the two coordinates of the image the first WCS is from.
+    """
+
+    first_naxis1, first_naxis2 = first_wcs.pixel_shape
+
+    # We add one to the pixel co-ordinates before the transformation and subtract
+    # it afterwards because wcs co-ordinates are one based, while pixel co-ordinates
+    # are zero based, The result is the final values in pixmap give a tranformation
+    # between the pixel co-ordinates in the first image to pixel co-ordinates in the
+    # co-ordinate system of the second.
+
+    one = np.ones(2, dtype='float64')
+    idxmap = np.indices((first_naxis1, first_naxis2), dtype='float64')
+    idxmap = idxmap.transpose() + one
+
+    idxmap = idxmap.reshape(first_naxis2 * first_naxis1, 2)
+
+    worldmap = first_wcs.all_pix2world(idxmap, 1)
+
+    if second_wcs.sip is None:
+        pixmap = second_wcs.wcs_world2pix(worldmap, 1)
+    else:
+        pixmap = second_wcs.all_world2pix(worldmap, 1)
+
+    pixmap = pixmap.reshape(first_naxis2, first_naxis1, 2)
+    pixmap = pixmap - one
+
+    return pixmap

drizzle/doblot.py

@@ -0,0 +1,80 @@
+"""
+STScI Python compatable blot module
+"""
+import numpy as np
+
+from drizzle import calc_pixmap
+from drizzle import cdrizzle
+
+
+def doblot(source, source_wcs, blot_wcs, exptime, coeffs=True,
+           interp='poly5', sinscl=1.0, stepsize=10, wcsmap=None):
+    """
+    Low level routine for performing the 'blot' operation.
+
+    Create a single blotted image from a single source image. The
+    interface is compatible with STScI code. All distortion information
+    is assumed to be included in the WCS specification of the 'output'
+    blotted image given in 'blot_wcs'.
+
+    Parameters
+    ----------
+
+    source : 2d array
+        Input numpy array of the source image in units of 'cps'.
+
+    source_wcs : wcs
+        The source image WCS.
+
+    blot_wcs : wcs
+        The blotted image WCS. The WCS that the source image will be
+        resampled to.
+
+    exptime : float
+        The exposure time of the input image.
+
+    interp : str, optional
+        The type of interpolation used in the blotting. The
+        possible values are "nearest" (nearest neighbor interpolation),
+        "linear" (bilinear interpolation), "poly3" (cubic polynomial
+        interpolation), "poly5" (quintic polynomial interpolation),
+        "sinc" (sinc interpolation), "lan3" (3rd order Lanczos
+        interpolation), and "lan5" (5th order Lanczos interpolation).
+
+    sincscl : float, optional
+        The scaling factor for sinc interpolation.
+
+    Returns
+    -------
+
+    A 2d numpy array with the blotted image
+
+    Other Parameters
+    ----------------
+
+    coeffs : bool, optional
+        Not used. Only kept for backwards compatibility.
+
+    stepsize : float, optional
+        Was used when input to output mapping was computed
+        internally. Is no longer used and only here for backwards compatibility.
+
+    wcsmap : function, optional
+        Was used when input to output mapping was computed
+        internally. Is no longer used and only here for backwards compatibility.
+    """
+    _outsci = np.zeros(blot_wcs.pixel_shape[::-1], dtype=np.float32)
+
+    # compute the undistorted 'natural' plate scale
+    blot_wcs.sip = None
+    blot_wcs.cpdis1 = None
+    blot_wcs.cpdis2 = None
+    blot_wcs.det2im = None
+
+    pixmap = calc_pixmap.calc_pixmap(blot_wcs, source_wcs)
+    pix_ratio = source_wcs.pscale / blot_wcs.pscale
+
+    cdrizzle.tblot(source, pixmap, _outsci, scale=pix_ratio, kscale=1.0,
+                   interp=interp, exptime=exptime, misval=0.0, sinscl=sinscl)
+
+    return _outsci

drizzle/dodrizzle.py

@@ -0,0 +1,189 @@
+"""
+STScI Python compatable drizzle module
+"""
+import numpy as np
+
+from . import util
+from . import calc_pixmap
+from . import cdrizzle
+
+
+def dodrizzle(insci, input_wcs, inwht,
+              output_wcs, outsci, outwht, outcon,
+              expin, in_units, wt_scl,
+              wcslin_pscale=1.0, uniqid=1,
+              xmin=0, xmax=0, ymin=0, ymax=0,
+              pixfrac=1.0, kernel='square', fillval="INDEF"):
+    """
+    Low level routine for performing 'drizzle' operation.on one image.
+
+    The interface is compatible with STScI code. All images are Python
+    ndarrays, instead of filenames. File handling (input and output) is
+    performed by the calling routine.
+
+    Parameters
+    ----------
+
+    insci : 2d array
+        A 2d numpy array containing the input image to be drizzled.
+        it is an error to not supply an image.
+
+    input_wcs : 2d array
+        The world coordinate system of the input image.
+
+    inwht : 2d array
+        A 2d numpy array containing the pixel by pixel weighting.
+        Must have the same dimensions as insci. If none is supplied,
+        the weghting is set to one.
+
+    output_wcs : wcs
+        The world coordinate system of the output image.
+
+    outsci : 2d array
+        A 2d numpy array containing the output image produced by
+        drizzling. On the first call it should be set to zero.
+        Subsequent calls it will hold the intermediate results
+
+    outwht : 2d array
+        A 2d numpy array containing the output counts. On the first
+        call it should be set to zero. On subsequent calls it will
+        hold the intermediate results.
+
+    outcon : 2d or 3d array, optional
+        A 2d or 3d numpy array holding a bitmap of which image was an input
+        for each output pixel. Should be integer zero on first call.
+        Subsequent calls hold intermediate results.
+
+    expin : float
+        The exposure time of the input image, a positive number. The
+        exposure time is used to scale the image if the units are counts.
+
+    in_units : str
+        The units of the input image. The units can either be "counts"
+        or "cps" (counts per second.)
+
+    wt_scl : float
+        A scaling factor applied to the pixel by pixel weighting.
+
+    wcslin_pscale : float, optional
+        The pixel scale of the input image. Conceptually, this is the
+        linear dimension of a side of a pixel in the input image, but it
+        is not limited to this and can be set to change how the drizzling
+        algorithm operates.
+
+    uniqid : int, optional
+        The id number of the input image. Should be one the first time
+        this function is called and incremented by one on each subsequent
+        call.
+
+    xmin : float, optional
+        This and the following three parameters set a bounding rectangle
+        on the input image. Only pixels on the input image inside this
+        rectangle will have their flux added to the output image. Xmin
+        sets the minimum value of the x dimension. The x dimension is the
+        dimension that varies quickest on the image. If the value is zero,
+        no minimum will be set in the x dimension. All four parameters are
+        zero based, counting starts at zero.
+
+    xmax : float, optional
+        Sets the maximum value of the x dimension on the bounding box
+        of the input image. If the value is zero, no maximum will
+        be set in the x dimension, the full x dimension of the output
+        image is the bounding box.
+
+    ymin : float, optional
+        Sets the minimum value in the y dimension on the bounding box. The
+        y dimension varies less rapidly than the x and represents the line
+        index on the input image. If the value is zero, no minimum  will be
+        set in the y dimension.
+
+    ymax : float, optional
+        Sets the maximum value in the y dimension. If the value is zero, no
+        maximum will be set in the y dimension,  the full x dimension
+        of the output image is the bounding box.
+
+    pixfrac : float, optional
+        The fraction of a pixel that the pixel flux is confined to. The
+        default value of 1 has the pixel flux evenly spread across the image.
+        A value of 0.5 confines it to half a pixel in the linear dimension,
+        so the flux is confined to a quarter of the pixel area when the square
+        kernel is used.
+
+    kernel: str, optional
+        The name of the kernel used to combine the input. The choice of
+        kernel controls the distribution of flux over the kernel. The kernel
+        names are: "square", "turbo", "point", "gaussian", "lanczos2",
+        and "lanczos3".
+
+        .. warning::
+            The "gaussian" and "lanczos2/3" kernels **DO NOT** conserve flux.
+
+    fillval: str, optional
+        The value a pixel is set to in the output if the input image does
+        not overlap it. The default value of INDEF does not set a value.
+
+    Returns
+    -------
+    A tuple with three values: a version string, the number of pixels
+    on the input image that do not overlap the output image, and the
+    number of complete lines on the input image that do not overlap the
+    output input image.
+
+    """
+
+    # Ensure that the fillval parameter gets properly interpreted
+    # for use with tdriz
+    if util.is_blank(fillval):
+        fillval = 'INDEF'
+    else:
+        fillval = str(fillval)
+
+    if in_units == 'cps':
+        expscale = 1.0
+    else:
+        expscale = expin
+
+    # Add input weight image if it was not passed in
+
+    if (insci.dtype > np.float32):
+        insci = insci.astype(np.float32)
+
+    if inwht is None:
+        inwht = np.ones_like(insci)
+
+    # Compute what plane of the context image this input would
+    # correspond to:
+    planeid = int((uniqid - 1) / 32)
+
+    # Check if the context image has this many planes
+    if outcon.ndim == 3:
+        nplanes = outcon.shape[0]
+    elif outcon.ndim == 2:
+        nplanes = 1
+    else:
+        nplanes = 0
+
+    if nplanes <= planeid:
+        raise IndexError("Not enough planes in drizzle context image")
+
+    # Alias context image to the requested plane if 3d
+    if outcon.ndim == 3:
+        outcon = outcon[planeid]
+
+    pix_ratio = output_wcs.pscale / wcslin_pscale
+
+    # Compute the mapping between the input and output pixel coordinates
+    pixmap = calc_pixmap.calc_pixmap(input_wcs, output_wcs)
+
+    #
+    # Call 'drizzle' to perform image combination
+    # This call to 'cdriz.tdriz' uses the new C syntax
+    #
+    _vers, nmiss, nskip = cdrizzle.tdriz(
+        insci, inwht, pixmap, outsci, outwht, outcon,
+        uniqid=uniqid, xmin=xmin, xmax=xmax,
+        ymin=ymin, ymax=ymax, scale=pix_ratio, pixfrac=pixfrac,
+        kernel=kernel, in_units=in_units, expscale=expscale,
+        wtscale=wt_scl, fillstr=fillval)
+
+    return _vers, nmiss, nskip