drizzle 1.15.2__cp311-cp311-win32.whl → 2.0.0__cp311-cp311-win32.whl

{drizzle-1.15.2.dist-info → drizzle-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drizzle
-Version: 1.15.2
+Version: 2.0.0
 Summary: A package for combining dithered images into a single image
 Author-email: STScI <help@stsci.edu>
 License: Copyright (C) 2011,2014 Association of Universities for Research in
@@ -49,15 +49,18 @@ Requires-Dist: sphinx ; extra == 'docs'
 Requires-Dist: sphinx-automodapi ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
 Requires-Dist: matplotlib ; extra == 'docs'
+Requires-Dist: pytest-doctestplus ; extra == 'docs'
 Requires-Dist: tomli ; (python_version < "3.11") and extra == 'docs'
 Provides-Extra: test
 Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: pytest-doctestplus ; extra == 'test'
 
 drizzle Documentation
 =====================
 
-.. image:: http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat
-    :target: http://www.astropy.org
+.. image:: https://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat
+    :target: https://www.astropy.org
     :alt: Powered by Astropy Badge
 
 .. image:: https://codecov.io/github/spacetelescope/drizzle/branch/main/graphs/badge.svg
@@ -76,6 +79,10 @@ drizzle Documentation
     :target: https://pypi.org/project/drizzle
     :alt: PyPI Status
 
+.. image:: https://zenodo.org/badge/28100377.svg
+    :target: https://doi.org/10.5281/zenodo.10672889
+    :alt: Zenodo DOI
+
 The ``drizzle`` library is a Python package for combining dithered images into a
 single image. This library is derived from code used in DrizzlePac. Like
 DrizzlePac, most of the code is implemented in the C language. The biggest
@@ -188,177 +195,8 @@ missing information.
 The blot methods perform the inverse operation of drizzle. That is, blotting
 performs the inverse mapping to transform the dithered median image back into
 the coordinate system of the original input image. Blotting is primarily used
-for identifying cosmic rays in the original image. Like the original drizzle
-task, blot requires the user to provide the world coordinate system (WCS)
-transformations as inputs.
+for identifying cosmic rays in the original image. Blot requires the user
+to provide the world coordinate system (WCS)-based transformations in the
+form of a pixel map array as input.
 
 .. [Driz2012] Gonzaga, S., Hack, W., Fruchter, A., Mack, J., eds. 2012, The DrizzlePac Handbook. (Baltimore, STScI)
-
-
-The Drizzle Library
--------------------
-
-The Drizzle library is object-oriented and you use it by first creating an object of
-the ``Drizzle`` class. To create a new Drizzle output image, supply an Astropy
-WCS object representing the coordinate system of the output image.
-The other parameters are the linear pixel dimension described in the previous
-section, the drizzle kernel used, how each input image is scaled (by exposure
-time or time squared), and the pixel value set in the output image where the
-input images do not overlap.
-
-After creating a Drizzle object, you add one or more images by calling the
-``add_fits_file`` method. The arguments are the name of the FITS file containing
-the input image and optionally the name of a FITS file containing the pixel
-weighting. Both file names can be followed by an extension name or number in
-square brackets. Optionally you can pass the name of the header keywords
-containing the exposure time and units. Two units are understood: counts and
-cps (counts per second).
-
-The following function is a demonstration of how you can create a new output
-image::
-
-    def drizzle_demo_one(reference, outfile, infiles):
-        """
-        First demonstration of drizzle
-
-        Parameters
-        ==========
-        reference
-            A file containing the wcs of the output image
-
-        outfile
-            The name of the output image
-
-        infiles
-            The names of the input images to be combined
-        """
-        # Get the WCS for the output image
-        hdulist = fits.open(reference)
-        reference_wcs = wcs.WCS(hdulist[1].header)
-
-        # Initialize the output with the WCS
-        driz = drizzle.drizzle.Drizzle(outwcs=reference_wcs)
-
-        # Combine the input images into on drizzle image
-        for infile in infiles:
-            driz.add_fits_file(infile)
-
-        # Write the drizzled image out
-        driz.write(outfile)
-
-Optionally you can supply the input and weight images as Numpy arrays by using
-the ``add_image`` method. If you use this method, you must supply the extra
-information that would otherwise be read from the FITS image: The WCS
-of the input image, the exposure time, and image units.
-
-Here is an example of how you would call ``add_image``::
-
-    def drizzle_demo_two(reference, outfile, infiles):
-        """
-        Demonstration of drizzle with add image.
-
-        Parameters
-        ==========
-        reference
-            A file containing the wcs of the output image.
-
-        outfile
-            The name of the output image.
-
-        infiles
-            The names of the input images to be combined.
-        """
-        # Get the WCS for the output image
-        reflist = fits.open(reference)
-        reference_wcs = wcs.WCS(reflist[1].header)
-
-        # Initialize the output with the WCS
-        driz = drizzle.drizzle.Drizzle(outwcs=reference_wcs)
-
-        # Combine the input images into on drizzle image
-        for infile in infiles:
-            # Open the file and read the image and wcs
-            # This is a contrived example, we would not do this
-            # unless the data came from another source
-            # than a FITS file
-            imlist = fits.open(reference)
-            image = imlist[1].data
-            image_wcs = wcs.WCS(imlist[1].header)
-            driz.add_image(image, image_wcs)
-
-        # Write the drizzled image out
-        driz.write(outfile)
-
-After combining all the input images, you write the output image into a FITS
-file with the ``write`` method. You must pass the name of the output image and
-optionally the units. You can also supply a set of header cards to be added
-to the primary header of the output FITS file.
-
-You can also add more images to an existing Drizzle output file by creating
-a new Drizzle object and passing the existing output file name as the new
-object is created. In that case the output WCS and all
-other parameters are read from the file.
-
-Here is a demonstration of adding additional input images to a drizzled image::
-
-    def drizzle_demo_three(outfile, infiles):
-        """
-        Demonstration of drizzle and adding to an existing output.
-
-        Parameters
-        ==========
-        outfile
-            Name of output image that new files will be appended to.
-
-        infiles
-            The names of the input images to be added.
-        """
-        # Re-open the output file
-        driz = drizzle.drizzle.Drizzle(infile=outfile)
-
-        # Add the input images to the existing output image
-        for infile in infiles:
-            driz.add_fits_file(infile)
-
-        # Write the modified drizzled image out
-        driz.write(outfile)
-
-You can use the methods ``blot_fits_file`` and ``blot_image`` to transform the drizzled
-output image into another WCS. Most usually this is the
-coordinates of one of the input images and is used to identify cosmic rays or
-other defects. The two methods ``blot_fits_file`` and ``blot_image`` allow you to
-retrieve the WCS from the FITS file header or input it directly.
-The optional parameter ``interp`` allows you to selct the method used to resample
-the pixels on the new grid, and ``sincscl`` is used to scale the sinc function if one
-of the sinc interpolation methods is used. This function demonstrates how both
-methods are called::
-
-    def drizzle_demo_four(outfile, blotfile):
-        """
-        Demonstration of blot methods.
-
-        Parameters
-        ==========
-        outfile
-            Name of output image that will be converted.
-
-        blotfile
-            Name of image containing wcs to be transformed to.
-        """
-        # Open drizzle using the output file
-        # Transform it to another coordinate system
-        driz = drizzle.drizzle.Drizzle(infile=outfile)
-        driz.blot_fits_file(blotfile)
-        driz.write(outfile)
-
-        # Read the WCS and transform using it instead
-        # This is a contrived example
-        blotlist = fits.open(blotfile)
-        blot_wcs = wcs.WCS(blotlist[1].header)
-        driz = drizzle.drizzle.Drizzle(infile=outfile)
-        driz.blot_image(blot_wcs)
-        driz.write(outfile)
-
-The lower level function ``dodrizzle`` is present for backwards compatibility with
-the existing STScI DrizzlePac code and should not be used unless you are also
-concerned with this compatibility.

drizzle-2.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+drizzle/__init__.py,sha256=hMpqmjPhrUWTRU0eXNOcrpiqQFGp4lf9opY8FXqLLEQ,325
+drizzle/cdrizzle.cp311-win32.pyd,sha256=ZHL61abDTResCF7nZx-NxxltXgZw56elWXpMMnRW-QU,86528
+drizzle/resample.py,sha256=t6HCYNWwnz4-mKYtzIWDFIEkHOi84ZI5GD4x3L6Wp0k,28982
+drizzle/util.py,sha256=os9wHm1JkKiG5jtnNCZAXG3vnnXxLHBpi8OTWsiPI7k,845
+drizzle/utils.py,sha256=Mze8pASdCiSXEsIJNIGkTcLbqszpJrrE5U576AtkzeI,8776
+drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drizzle/tests/test_cdrizzle.py,sha256=utepqMiY8xtgQ8gBRBHwnlMhbBB1pq1xE4spf-wO7Kw,726
+drizzle/tests/test_overlap_calc.py,sha256=ucwDL9fd8NVAxTdz-sWum_uobhm-TGkCr2yl69BKiC4,7062
+drizzle/tests/test_resample.py,sha256=Xtov5vpVOEWOscKngGl8GkDyWSj_GpRNlceGIJ_Jdfg,41014
+drizzle/tests/test_utils.py,sha256=rlRvd7JKo7YeVPIhYAYg4WgXLN7yge39Zkngv8jq4ds,5889
+drizzle-2.0.0.dist-info/LICENSE.rst,sha256=sUXj5W73D9TcOw5ZXaDdcthYdY2b2dTJPsxBuZTOYWQ,1505
+drizzle-2.0.0.dist-info/METADATA,sha256=dv6lr7uK6t4T5IzDF4UYvS5vYXBFhd0ZWQdTPdFMJ0Y,10850
+drizzle-2.0.0.dist-info/WHEEL,sha256=5l39w2c7RLiOaKb0DCvi6tyvDZ-pTlvj48adpJViMnw,97
+drizzle-2.0.0.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
+drizzle-2.0.0.dist-info/RECORD,,

{drizzle-1.15.2.dist-info → drizzle-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win32
 

drizzle/calc_pixmap.py

@@ -1,52 +0,0 @@
-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

@@ -1,80 +0,0 @@
-"""
-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

@@ -1,189 +0,0 @@
-"""
-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