drizzle 1.15.3__cp312-cp312-win_amd64.whl → 2.0.1__cp312-cp312-win_amd64.whl

drizzle/utils.py

@@ -0,0 +1,285 @@
+import math
+
+import numpy as np
+
+__all__ = ["calc_pixmap", "decode_context", "estimate_pixel_scale_ratio"]
+
+_DEG2RAD = math.pi / 180.0
+
+
+def calc_pixmap(wcs_from, wcs_to, shape=None, disable_bbox="to"):
+    """
+    Calculate a discretized on a grid mapping between the pixels of two images
+    using provided WCS of the original ("from") image and the destination ("to")
+    image.
+
+    .. note::
+       This function assumes that output frames of ``wcs_from`` and ``wcs_to``
+       WCS have the same units.
+
+    Parameters
+    ----------
+    wcs_from : wcs
+        A WCS object representing the coordinate system you are
+        converting from. This object's ``array_shape`` (or ``pixel_shape``)
+        property will be used to define the shape of the pixel map array.
+        If ``shape`` parameter is provided, it will take precedence
+        over this object's ``array_shape`` value.
+
+    wcs_to : wcs
+        A WCS object representing the coordinate system you are
+        converting to.
+
+    shape : tuple, None, optional
+        A tuple of integers indicating the shape of the output array in the
+        ``numpy.ndarray`` order. When provided, it takes precedence over the
+        ``wcs_from.array_shape`` property.
+
+    disable_bbox : {"to", "from", "both", "none"}, optional
+        Indicates whether to use or not to use the bounding box of either
+        (both) ``wcs_from`` or (and) ``wcs_to`` when computing pixel map. When
+        ``disable_bbox`` is "none", pixel coordinates outside of the bounding
+        box are set to `NaN` only if ``wcs_from`` or (and) ``wcs_to`` sets
+        world coordinates to NaN when input pixel coordinates are outside of
+        the bounding box.
+
+    Returns
+    -------
+    pixmap : numpy.ndarray
+        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.
+
+    Raises
+    ------
+    ValueError
+        A `ValueError` is raised when output pixel map shape cannot be
+        determined from provided inputs.
+
+    Notes
+    -----
+    When ``shape`` is not provided and ``wcs_from.array_shape`` is not set
+    (i.e., it is `None`), `calc_pixmap` will attempt to determine pixel map
+    shape from the ``bounding_box`` property of the input ``wcs_from`` object.
+    If ``bounding_box`` is not available, a `ValueError` will be raised.
+
+    """
+    if (bbox_from := getattr(wcs_from, "bounding_box", None)) is not None:
+        try:
+            # to avoid dependency on astropy just to check whether
+            # the bounding box is an instance of
+            # modeling.bounding_box.ModelBoundingBox, we try to
+            # directly use and bounding_box(order='F') and if it fails,
+            # fall back to converting the bounding box to a tuple
+            # (of intervals):
+            bbox_from = bbox_from.bounding_box(order='F')
+        except AttributeError:
+            bbox_from = tuple(bbox_from)
+
+    if (bbox_to := getattr(wcs_to, "bounding_box", None)) is not None:
+        try:
+            # to avoid dependency on astropy just to check whether
+            # the bounding box is an instance of
+            # modeling.bounding_box.ModelBoundingBox, we try to
+            # directly use and bounding_box(order='F') and if it fails,
+            # fall back to converting the bounding box to a tuple
+            # (of intervals):
+            bbox_to = bbox_to.bounding_box(order='F')
+        except AttributeError:
+            bbox_to = tuple(bbox_to)
+
+    if shape is None:
+        shape = wcs_from.array_shape
+        if shape is None and bbox_from is not None:
+            if (nd := np.ndim(bbox_from)) == 1:
+                bbox_from = (bbox_from, )
+            if nd > 1:
+                shape = tuple(
+                    int(math.ceil(lim[1] + 0.5)) for lim in bbox_from[::-1]
+                )
+
+    if shape is None:
+        raise ValueError(
+            'The "from" WCS must have pixel_shape property set.'
+        )
+
+    y, x = np.indices(shape, dtype=np.float64)
+
+    # temporarily disable the bounding box for the "from" WCS:
+    if disable_bbox in ["from", "both"] and bbox_from is not None:
+        wcs_from.bounding_box = None
+    if disable_bbox in ["to", "both"] and bbox_to is not None:
+        wcs_to.bounding_box = None
+    try:
+        x, y = wcs_to.world_to_pixel_values(
+            *wcs_from.pixel_to_world_values(x, y)
+        )
+    finally:
+        if bbox_from is not None:
+            wcs_from.bounding_box = bbox_from
+        if bbox_to is not None:
+            wcs_to.bounding_box = bbox_to
+
+    pixmap = np.dstack([x, y])
+    return pixmap
+
+
+def estimate_pixel_scale_ratio(wcs_from, wcs_to, refpix_from=None, refpix_to=None):
+    """
+    Compute the ratio of the pixel scale of the "to" WCS at the ``refpix_to``
+    position to the pixel scale of the "from" WCS at the ``refpix_from``
+    position. Pixel scale ratio,
+    when requested, is computed near the centers of the bounding box
+    (a property of the WCS object) or near ``refpix_*`` coordinates
+    if supplied.
+
+    Pixel scale is estimated as the square root of pixel's area, i.e.,
+    pixels are assumed to have a square shape at the reference
+    pixel position. If input reference pixel position for a WCS is `None`,
+    it will be taken as the center of the bounding box
+    if ``wcs_*`` has a bounding box defined, or as the center of the box
+    defined by the ``pixel_shape`` attribute of the input WCS if
+    ``pixel_shape`` is defined (not `None`), or at pixel coordinates
+    ``(0, 0)``.
+
+    Parameters
+    ----------
+    wcs_from : wcs
+        A WCS object representing the coordinate system you are
+        converting from. This object *must* have ``pixel_shape`` property
+        defined.
+
+    wcs_to : wcs
+        A WCS object representing the coordinate system you are
+        converting to.
+
+    refpix_from : numpy.ndarray, tuple, list
+        Image coordinates of the reference pixel near which pixel scale should
+        be computed in the "from" image. In FITS WCS this could be, for example,
+        the value of CRPIX of the ``wcs_from`` WCS.
+
+    refpix_to : numpy.ndarray, tuple, list
+        Image coordinates of the reference pixel near which pixel scale should
+        be computed in the "to" image. In FITS WCS this could be, for example,
+        the value of CRPIX of the ``wcs_to`` WCS.
+
+    Returns
+    -------
+    pixel_scale_ratio : float
+        Estimate the ratio of "to" to "from" WCS pixel scales. This value is
+        returned only when ``estimate_pixel_scale_ratio`` is `True`.
+
+    """
+    pscale_ratio = (_estimate_pixel_scale(wcs_to, refpix_to) /
+                    _estimate_pixel_scale(wcs_from, refpix_from))
+    return pscale_ratio
+
+
+def _estimate_pixel_scale(wcs, refpix):
+    # estimate pixel scale (in rad) using approximate algorithm
+    # from https://trs.jpl.nasa.gov/handle/2014/40409
+    if refpix is None:
+        if hasattr(wcs, 'bounding_box') and wcs.bounding_box is not None:
+            refpix = np.mean(wcs.bounding_box, axis=-1)
+        else:
+            if wcs.pixel_shape:
+                refpix = np.array([(i - 1) // 2 for i in wcs.pixel_shape])
+            else:
+                refpix = np.zeros(wcs.pixel_n_dim)
+
+    else:
+        refpix = np.asarray(refpix)
+
+    l1, phi1 = wcs.pixel_to_world_values(*(refpix - 0.5))
+    l2, phi2 = wcs.pixel_to_world_values(*(refpix + [-0.5, 0.5]))
+    l3, phi3 = wcs.pixel_to_world_values(*(refpix + 0.5))
+    l4, phi4 = wcs.pixel_to_world_values(*(refpix + [0.5, -0.5]))
+    area = _DEG2RAD * abs(
+        0.5 * (
+            (l4 - l2) * (math.sin(_DEG2RAD * phi1) - math.sin(_DEG2RAD * phi3)) +
+            (l1 - l3) * (math.sin(_DEG2RAD * phi2) - math.sin(_DEG2RAD * phi4))
+        )
+    )
+    return math.sqrt(area)
+
+
+def decode_context(context, x, y):
+    """Get 0-based indices of input images that contributed to (resampled)
+    output pixel with coordinates ``x`` and ``y``.
+
+    Parameters
+    ----------
+    context: numpy.ndarray
+        A 3D `~numpy.ndarray` of integral data type.
+
+    x: int, list of integers, numpy.ndarray of integers
+        X-coordinate of pixels to decode (3rd index into the ``context`` array)
+
+    y: int, list of integers, numpy.ndarray of integers
+        Y-coordinate of pixels to decode (2nd index into the ``context`` array)
+
+    Returns
+    -------
+    A list of `numpy.ndarray` objects each containing indices of input images
+    that have contributed to an output pixel with coordinates ``x`` and ``y``.
+    The length of returned list is equal to the number of input coordinate
+    arrays ``x`` and ``y``.
+
+    Examples
+    --------
+    An example context array for an output image of array shape ``(5, 6)``
+    obtained by resampling 80 input images.
+
+    >>> import numpy as np
+    >>> from drizzle.utils import decode_context
+    >>> ctx = np.array(
+    ...     [[[0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 0, 36196864, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 537920000, 0, 0, 0]],
+    ...      [[0, 0, 0, 0, 0, 0,],
+    ...       [0, 0, 0, 67125536, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 163856, 0, 0, 0]],
+    ...      [[0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 0, 8203, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 0, 0, 0, 0],
+    ...       [0, 0, 32865, 0, 0, 0]]],
+    ...     dtype=np.int32
+    ... )
+    >>> decode_context(ctx, [3, 2], [1, 4])
+    [array([ 9, 12, 14, 19, 21, 25, 37, 40, 46, 58, 64, 65, 67, 77]),
+     array([ 9, 20, 29, 36, 47, 49, 64, 69, 70, 79])]
+
+    """
+    if context.ndim != 3:
+        raise ValueError("'context' must be a 3D array.")
+
+    x = np.atleast_1d(x)
+    y = np.atleast_1d(y)
+
+    if x.size != y.size:
+        raise ValueError("Coordinate arrays must have equal length.")
+
+    if x.ndim != 1:
+        raise ValueError("Coordinates must be scalars or 1D arrays.")
+
+    if not (np.issubdtype(x.dtype, np.integer) and
+            np.issubdtype(y.dtype, np.integer)):
+        raise ValueError('Pixel coordinates must be integer values')
+
+    nbits = 8 * context.dtype.itemsize
+    one = np.array(1, context.dtype)
+    flags = np.array([one << i for i in range(nbits)])
+
+    idx = []
+    for xi, yi in zip(x, y):
+        idx.append(
+            np.flatnonzero(np.bitwise_and.outer(context[:, yi, xi], flags))
+        )
+
+    return idx

{drizzle-1.15.3.dist-info → drizzle-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: drizzle
-Version: 1.15.3
+Version: 2.0.1
 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
@@ -39,25 +39,29 @@ Project-URL: Homepage, https://github.com/spacetelescope/drizzle
 Project-URL: Bug Tracker, https://github.com/spacetelescope/drizzle/issues
 Project-URL: Documentation, http://spacetelescope.github.io/drizzle/
 Project-URL: Source Code, https://github.com/spacetelescope/drizzle
-Requires-Python: <3.13,>=3.10
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: numpy
-Requires-Dist: astropy
-Provides-Extra: docs
-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: tomli ; (python_version < "3.11") and extra == 'docs'
 Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: astropy; extra == "test"
+Requires-Dist: gwcs; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-doctestplus; extra == "test"
+Provides-Extra: docs
+Requires-Dist: tomli; python_version < "3.11" and extra == "docs"
+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"
 
 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 +80,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 +196,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.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+drizzle/__init__.py,sha256=hMpqmjPhrUWTRU0eXNOcrpiqQFGp4lf9opY8FXqLLEQ,325
+drizzle/cdrizzle.cp312-win_amd64.pyd,sha256=Z_bravdwLIPsYXZdBQKn7XOQtlnXbwuYDfZxqEw-KEk,100864
+drizzle/resample.py,sha256=LXc3TxaXvOd05zrszMa94JZbMSu7T3kDn4zoL3N7yeI,28982
+drizzle/util.py,sha256=os9wHm1JkKiG5jtnNCZAXG3vnnXxLHBpi8OTWsiPI7k,845
+drizzle/utils.py,sha256=hz6TVSb5dWIVw3P28EeeSc6PjVJNy4JAG5tB1v1yIrE,10846
+drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drizzle/tests/helpers.py,sha256=BF_IbAwBZFgrTglw33Mgw56xfKYqNJXVTtjCwUB_U98,5887
+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=13UfYaGtTT2utQfF7j_8pQXzC51RFZ8EpRLFYSdz1MM,31600
+drizzle/tests/test_utils.py,sha256=s4-z4ZMTcoIUyxHW0pMRpQB2GiA1lbfuNLQzkOgflp8,7691
+drizzle-2.0.1.dist-info/LICENSE.rst,sha256=sUXj5W73D9TcOw5ZXaDdcthYdY2b2dTJPsxBuZTOYWQ,1505
+drizzle-2.0.1.dist-info/METADATA,sha256=2G_rWumBwJpBy9MC7qc_c7CHA3qj_4RLxIHehazIIdM,10894
+drizzle-2.0.1.dist-info/WHEEL,sha256=cRmSBGD-cl98KkuHMNqv9Ac9L9_VqTvcBYwpIvxN0cg,101
+drizzle-2.0.1.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
+drizzle-2.0.1.dist-info/RECORD,,

{drizzle-1.15.3.dist-info → drizzle-2.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64
 

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