numpyimage 1.1.1__tar.gz → 1.2.0__tar.gz

numpyimage-1.2.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: numpyimage
+Version: 1.2.0
+Summary: Load, save, and manipulate image files as numpy arrays
+Home-page: https://github.com/jasper-tms/npimage
+Author: Jasper Phelps
+Author-email: jasper.s.phelps@gmail.com
+License: GNU GPL v3
+Description: # npimage
+        Need to load pixel values from image files as numpy arrays, and hate having to remember whether you should use PIL, tifffile, matplotlib, or something else? Hate having to deal with the fact that those libraries all use different function names and syntaxes? Wish you could just provide a filename and get back a numpy array? This library's `core.py` does that, with `array = load(filename)`, `save(array, filename)`, and `show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. (Another choice of library to consider for accomplishing similar goals is [imageio](https://pypi.org/project/imageio/), which also supports loading videos through the FFmpeg wrapper library [pyav](https://pypi.org/project/av/).)
+        
+        Want to draw simple shapes like lines, triangles, and circles into 3D numpy arrays? Frustrated that the python libraries you can find online like `opencv` and `skimage.draw` work on 2D arrays but not 3D? I wrote some functions in `graphics.py` that do the trick in 3D. (If you know of another library that can do this, please let me know!)
+        
+        
+        ### Documentation
+        - `core.py`: load, save, or show images.
+        - `graphics.py`: draw points, lines, triangles, circles, or spheres into 2D or 3D numpy arrays representing image volumes.
+        - `nrrd_utils.py`: compress or read metadata from `.nrrd` files.
+        - `operations.py`: perform operations on images.
+        
+        For now, check each function's docstring for more. A jupyter notebook demonstrating this package's functions will come later.
+        
+        
+        ### Installation
+        
+        As is always the case in python, consider making a virtual environment (using your preference of conda, virtualenv, or virtualenvwrapper) before installing.
+        
+        **Option 1:** `pip install` from PyPI:
+        
+            pip install numpyimage
+        
+        (Unfortunately the name `npimage` was already taken on PyPI, so `pip install npimage` will get you a different package.)
+        
+        **Option 2:** `pip install` directly from GitHub:
+            
+            pip install git+https://github.com/jasper-tms/npimage.git
+        
+        **Option 3:** First `git clone` this repo and then `pip install` it from your clone:
+        
+            cd ~/repos  # Or wherever on your computer you want to download this code to
+            git clone https://github.com/jasper-tms/npimage.git
+            cd npimage
+            pip install .
+        
+        **After installing,** you can import this package in python using `import npimage` (not `import numpyimage`!)
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

{numpyimage-1.1.1 → numpyimage-1.2.0}/npimage/core.py

@@ -110,7 +110,7 @@ read = load  # Function name alias
 imread = load  # Function name alias
 
 
-def save(data, filename, dim_order='zyx', metadata=None, compress=False):
+def save(data, filename, overwrite=False, dim_order='zyx', metadata=None, compress=False):
     """
     Save a numpy array to file with a file type specified by the
     filename extension.
@@ -124,8 +124,10 @@ def save(data, filename, dim_order='zyx', metadata=None, compress=False):
 
     `compress` only matters when saving in `.nrrd` format
     """
-    while filename.endswith('/'):
-        filename = filename[:-1]
+    filename = filename.rstrip('/')
+    if os.path.exists(filename) and not overwrite:
+        raise Exception(f'File {filename} already exists. '
+                        'Set overwrite=True to overwrite.')
     extension = filename.split('.')[-1]
     assert extension in supported_extensions, f'Filetype {extension} not supported'
 
@@ -176,10 +178,53 @@ def save(data, filename, dim_order='zyx', metadata=None, compress=False):
     if extension == 'zarr':
         raise NotImplementedError
 
+
 write = save  # Function name alias
 to_file = save  # Function name alias
 
 
+def save_video(data, filename, overwrite=False, dim_order='yx', time_axis=0,
+               framerate=30, crf=23, compression_speed='medium'):
+    """
+    Save a 3D numpy array as a video, with a specified axis as the time axis.
+
+    Follows the PyAV cookbook section on generating video from numpy arrays:
+    https://pyav.basswood-io.com/docs/develop/cookbook/numpy.html#generating-video
+    """
+    if not data.ndim == 3:
+        raise ValueError('Input data must be a 3D numpy array.')
+    try:
+        import av
+    except ImportError:
+        raise ImportError('To save videos, you must have PyAV installed. '
+                          'You can install it with "pip install av".')
+    data = np.moveaxis(data, time_axis, 0)
+    if 'xy' in dim_order:
+        data = data.swapaxes(1, 2)
+    n_frames = data.shape[0]
+
+    if os.path.exists(filename) and not overwrite:
+        raise Exception(f'File {filename} already exists. '
+                        'Set overwrite=True to overwrite.')
+    container = av.open(filename, mode='w')
+
+    stream = container.add_stream('libx264', rate=framerate)
+    stream.pix_fmt = 'yuv420p'
+    stream.options = {'crf': str(crf), 'preset': compression_speed}
+    stream.height = data.shape[1]
+    stream.width = data.shape[2]
+
+    for frame_i in range(n_frames):
+        frame = av.VideoFrame.from_ndarray(data[frame_i], format='gray')
+        for packet in stream.encode(frame):
+            container.mux(packet)
+
+    for packet in stream.encode():
+        container.mux(packet)
+
+    container.close()
+
+
 def show(data, dim_order='yx', mode='PIL', **kwargs):
     """
     Display a numpy array of pixel values as an image. Supported types:

{numpyimage-1.1.1 → numpyimage-1.2.0}/npimage/nrrd_utils.py

@@ -38,14 +38,19 @@ def compress(*fn_patterns, keep_uncompressed=False):
             nrrd.write(fn, data, header=header)
 
 
-def read_headers(*fn_patterns):
+def read_headers(*fn_patterns, verbose=True):
+    headers = dict()
     if len(fn_patterns) == 0:
         fn_patterns = ['*.nrrd']
-        print('Reading headers of all nrrd files in this directory.\n')
+        if verbose:
+            print('Reading headers of all nrrd files in this directory.')
     for fn_pattern in fn_patterns:
-        for fn in glob.glob(fn_pattern):
-            print(fn)
-            print(nrrd.read_header(fn), '\n')
+        for fn in sorted(glob.glob(fn_pattern)):
+            if verbose:
+                print(f'Reading header of {fn}')
+            headers[fn] = nrrd.read_header(fn)
+
+    return headers
 
 
 if __name__ == '__main__':

numpyimage-1.2.0/npimage/operations.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+
+from collections.abc import Iterable
+from typing import Literal
+import gc
+
+import numpy as np
+#import cv2
+
+from .utils import iround, eq, isint
+
+
+def to_8bit(image: np.ndarray,
+            bottom_percentile=0.05,
+            top_percentile=99.95,
+            bottom_value=None,
+            top_value=None) -> np.ndarray:
+    """
+    Convert an image to 8-bit (uint8) by scaling the image's pixel values so
+    that values <= bottom_value are mapped to 0 and values >= top_value are
+    mapped to 255. Values within the range (bottom_value, top_value) will be
+    mapped linearly into the range [1, 254]. By default, bottom_value and
+    top_value are set to percentiles of the source image's pixel values.
+    Some examples:
+    - Set bottom_percentile=0 to map only the minimum value in the source image
+      to 0 and and top_percentile=100 to map only the maximum value in the
+      source image to 255, and all other values to the range [1, 254].
+    - Set bottom_percentile=25 to map all of the the lowest 25% of the source
+      image's pixel values to 0 and set top_percentile=75 to map all of the
+      highest 25% of the source image's pixel values to 255.
+    The defaults are:
+    - bottom_percentile=0.05
+    - top_percentile=99.95
+    which are ~3.3 standard deviations below and above the mean, respectively,
+    if the pixel values are approximately normally distributed. (Compared to
+    using percentiles of 0 and 100, using these percentiles lessens the impact
+    of a few extreme outlier pixel values in the image.)
+
+    You may however specify bottom_value and/or top_value explicitly yourself,
+    in which case bottom_percentile and/or top_percentile will be ignored.
+
+    Algorithm:
+    - Clip values < bottom_value or > top_value
+      (i.e. replace them with bottom_value or top_value)
+    - Map the range [bottom_value, top_value] to
+      [just less than 1, just greater than 255]
+    - Cast to int (which rounds down)
+    From these steps, values will be transformed as follows:
+    - bottom_value or less -> just less than 1 -> 0
+    - a value just greater than bottom_value -> just greater than 1 -> 1
+    - top_value or larger -> just greater than 255 -> 255
+    - a value just less than top_value -> just less than 255 -> 254
+    - values between bottom_value and top_value -> linearly mapped to
+      values between 1 and 254
+    """
+    assert isinstance(image, np.ndarray)
+
+    if bottom_value is None or top_value is None:
+        percentiles = np.percentile(image, [bottom_percentile, top_percentile])
+    if bottom_value is None:
+        bottom_value = percentiles[0]
+    if top_value is None:
+        top_value = percentiles[1]
+
+    if bottom_value == top_value:
+        raise ZeroDivisionError('top_value and bottom_value are the same: '
+                                '{}'.format(top_value))
+
+    image = np.clip(image, bottom_value, top_value)
+
+    bottom_target = 1 - 1e-12
+    top_target = 255 + 1e-12
+    # TODO some more clever implementation that doesn't require casting to
+    # float64, which can take up a lot of memory.
+    return ((image.astype('float64') - bottom_value)
+            / (top_value - bottom_value)
+            * (top_target - bottom_target)
+            + bottom_target).astype('uint8')
+
+
+def downsample(image: np.ndarray,
+               factor: [int, Iterable] = 2,
+               keep_input_dtype=True) -> np.ndarray:
+    """
+    Downsample an image by a given factor along each axis.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        The image to downsample.
+
+    factor : int or Iterable
+        An iterable with length matching the number of axes in the image,
+        specifying a downsampling factor along each axis.
+        If factor is provided as an int, that int will be used for each axis.
+        If the image is rgb or rgba (that is, the final axis has length 3 or
+        4), it is not necessary to specify a factor for that axis and so the
+        'factor' iterable can be one element shorter than the number of axes in
+        the image.
+
+    keep_input_dtype : bool
+        If True, the output image will have the same dtype as the input image.
+        If False, the output image will have dtype float64 to keep full precision.
+    """
+    if isinstance(factor, int):
+        if image.shape[-1] in [3, 4]:
+            # If RGB/RGBA image, don't downsample the colors axis
+            factor = (factor,) * (len(image.shape) - 1)
+        else:
+            factor = (factor,) * len(image.shape)
+    if len(factor) == len(image.shape) - 1 and image.shape[-1] in [3, 4]:
+        print('RGB/RGBA image detected - not downsampling last axis.')
+        factor = (*factor, 1)
+    if any([f > l > 1 for f, l in zip(factor, image.shape)]):
+        raise ValueError('Downsampling factor must be <= image size along each axis')
+
+    # In the code below, 'l' is used for the elements of image.shape and 'f' is
+    # used for the elements of factor.
+    padding = [(0, 0) if l % f == 0
+               else (0, f - l % f)
+               for l, f in zip(image.shape, factor)]
+    # Pad the image so that its axes are a multiple of the downsampling factor
+    # This is necessary because the image will be split into blocks of size
+    # 'factor' and then the mean of each block will be taken, so the image
+    # needs to be a multiple of 'factor' in size so that the blocks are all
+    # the same size.
+    image = np.pad(image, padding, mode='edge')
+    if not all([(l == 1) or (l % f == 0) for l, f in zip(image.shape, factor)]):
+        raise RuntimeError('Padding failed: shape should be a multiple of factor')
+
+    # For any dimension with length > 1, split it into blocks of size f, then
+    # average over each block.
+    temp_shape = []
+    for l, f in zip(image.shape, factor):
+        if l == 1:
+            if f != 1:
+                raise ValueError("You can't downsample along"
+                                 " an axis of length 1.")
+            temp_shape.extend([1, 1])
+        else:
+            temp_shape.extend([l // f, f])
+    axes_to_avg = tuple(range(1, len(temp_shape), 2))
+    image_downsampled = image.reshape(temp_shape).mean(axis=axes_to_avg)
+
+    if keep_input_dtype:
+        if np.issubdtype(image.dtype, np.integer):
+            image_downsampled = iround(image_downsampled, output_dtype=image.dtype)
+        else:
+            image_downsampled = image_downsampled.astype(image.dtype)
+
+    return image_downsampled
+
+
+def offset(image: np.ndarray,
+           distance: float or Iterable[float],
+           axis: int = None,
+           expand_bounds: bool = False,
+           edge_mode: Literal['extend', 'wrap',
+                              'reflect', 'constant'] = 'extend',
+           edge_fill_value=0,
+           fill_transparent=False) -> np.ndarray:
+    """
+    Offset an image by a given distance.
+
+    'distance' must be an iterable with length matching the number of axes in
+    the image, to specify an number of pixels to offset along each axis. If the
+    image is rgb or rgba (that is, the final axis has length 3 or 4), it is not
+    necessary to specify an offset for that axis and so the 'distance' iterable
+    can be one element shorter than the number of axes in the image.
+
+    If edge_mode is set to 'constant', the pixels no longer occupied by the
+    original image as a result of the offset will be filled in with
+    'edge_fill_value'.
+
+    See also scipy.ndimage.shift, which performs a very similar operation
+    """
+    try:
+        iter(distance)
+        if axis is not None:
+            raise ValueError('Either give distance as one number and specify'
+                             ' axis, or give distance as an iterable. You'
+                             ' did a mix of those two.')
+    except TypeError:
+        distance_iter = [0] * len(image.shape)
+        if axis is None:
+            raise ValueError('Must specify axis when giving distance as a'
+                             ' single number.')
+        distance_iter[axis] = distance
+        distance = distance_iter
+    if edge_mode not in ['extend', 'wrap', 'reflect', 'constant']:
+        raise ValueError("edge_mode must be one of 'extend', 'wrap', 'reflect', or 'constant'")
+    if edge_mode in ['wrap', 'reflect']:
+        raise NotImplementedError("edge_mode '{}' not yet implemented".format(edge_mode))
+
+    if len(image.shape) == len(distance) + 1 and image.shape[-1] in [1, 3, 4]:
+        # Specify no offset along the channels axis, if not specified by user
+        distance = (*distance, 0)
+
+    if len(image.shape) != len(distance):
+        m = (f'distance must have length {len(image.shape)} to specify an'
+             ' offset along each axis of the image, but instead had length'
+             f' {len(distance)}')
+        raise ValueError(m)
+
+    if not expand_bounds:
+        new_image = np.full_like(image, edge_fill_value)
+    else:
+        new_shape = np.array(image.shape) + np.array([int(max(0, d)) for d in distance])
+        new_image = np.full(new_shape, edge_fill_value, dtype=image.dtype)
+
+    if image.shape[-1] == 4 and not fill_transparent:
+        # If rgba, set alpha channel value to max
+        # The line below means new_image[:, :, :, ..., :, -1] = 255
+        new_image[tuple([slice(None, None)] * (len(image.shape)-1) + [-1])] = 255
+
+    distance_int = [int(x) for x in distance]
+
+    source_range = [slice(max(0, -d), min(s, s-d)) for d, s in zip(distance_int, new_image.shape)]
+    target_range = [slice(max(0, d), min(s, s+d)) for d, s in zip(distance_int, new_image.shape)]
+
+    new_image[tuple(target_range)] = image[tuple(source_range)]
+
+    for i, d in enumerate(distance):
+        if not eq(d, int(d)):
+            _offset_subpixel(new_image, d - int(d), i,
+                             edge_fill_value=edge_fill_value,
+                             fill_transparent=fill_transparent, inplace=True)
+
+    return new_image
+
+
+def _offset_subpixel(image: np.ndarray,
+                     distance: float,
+                     axis: int,
+                     edge_mode: Literal['extend', 'wrap',
+                                        'reflect', 'constant'] = 'extend',
+                     edge_fill_value=0,
+                     fill_transparent=False,
+                     inplace=False):
+    """
+    Offset an image by a fraction of a pixel along a single specified axis.
+
+    If an offset of 0.1 is requested, the output will be 10% of the image
+    shifted one pixel upward plus 90% of the original image.
+    If an offset of -0.1 is requested, the output will be 10% of the image
+    shifted one pixel downward plus 90% of the original image.
+    If an offset of 0.5 is requested, the output will be 50% of the image
+    shifted one pixel upward plus 50% of the original image.
+    etc.
+
+    The pixels no longer occupied by the original image as a result of the
+    offset will be filled in with 'edge_fill_value'.
+    """
+    assert -1 < distance and distance < 1
+
+    one_pix_offset = [0] * len(image.shape)
+    one_pix_offset[axis] = 1 if distance >= 0 else -1
+    image_1pix_shifted = offset(image, one_pix_offset,
+                                edge_fill_value=edge_fill_value,
+                                fill_transparent=fill_transparent)
+    distance = abs(distance)
+
+    if np.issubdtype(image.dtype, np.integer):
+        # If the input array is an integer type, we should avoid creating a
+        # float version of the array during calculations, because float arrays
+        # can take up an unacceptable amount of memory. (e.g. If I write lazy
+        # code that ends up multiplying a uint8 array by a fractional value
+        # like 0.5, a float64 array is created which takes up 8x the amount of
+        # memory as the source array. And we need to make two of these!).
+        # Instead, we will do a trick of increasing the bit-depth of the source
+        # array by 1 byte (or a few bytes, since numpy only works with bit
+        # depths that are a power of 2, e.g. uint24 isn't a thing), use that
+        # additional range to keep some accuracy during the weighted average
+        # calculation, then cast back to the original dtype.
+
+        upcast_dtype = np.dtype(f'{image.dtype.kind}{image.dtype.itemsize * 2}')
+        image_upcast = image.astype(upcast_dtype)
+        image_1pix_shifted_upcast = image_1pix_shifted.astype(upcast_dtype)
+
+        # We'll use the extra bit of precision to enable us to use integer
+        # weights from 0 to 255 instead of float weights from 0.0 to 1.0
+        image_weight = int(256 * (1 - distance))
+        image_1pix_shifted_weight = int(256 * distance)
+        # Adding 127 before dividing by 256 means we round to the nearest
+        # integer instead of truncating (which we'd get without the 127)
+        image_subpix_shifted = (
+            (image_upcast * image_weight) +
+            (image_1pix_shifted_upcast * image_1pix_shifted_weight) +
+            127
+        ) // 256
+        del image_upcast, image_1pix_shifted_upcast, image_1pix_shifted
+        gc.collect()
+
+        # Now cast back to the original dtype
+        image_subpix_shifted = image_subpix_shifted.astype(image.dtype)
+
+    elif np.issubdtype(image.dtype, np.floating):
+        image_subpix_shifted = image * (1 - distance) + image_1pix_shifted * distance
+
+    if inplace:
+        image[:] = image_subpix_shifted
+    else:
+        return image_subpix_shifted
+
+
+def paste(image: np.ndarray,
+          target: np.ndarray,
+          offset: Iterable[float]):
+    """
+    Paste an image onto another image at a given offset.
+
+    `target` is modified in place. Regions of `image` that would be
+    pasted outside the bounds of `target` are ignored.
+    """
+    image = image.copy()
+    offset_int = [int(x) for x in offset]
+    offset_subpixel = [x - int(x) for x in offset]
+    for i, offset in enumerate(offset_subpixel):
+        if not eq(offset, 0):
+            _offset_subpixel(image, offset, i, inplace=True)
+
+    source_range = [slice(max(0, -o), min(s, t-o))
+                    for o, s, t in zip(offset_int, image.shape, target.shape)]
+    target_range = [slice(max(0, o), min(t, max(0, o) + min(s, t-o) - max(0, -o)))
+                    for o, s, t in zip(offset_int, image.shape, target.shape)]
+
+    target[tuple(target_range)] = image[tuple(source_range)]
+
+
+def overlay(ims: list[np.ndarray],
+            offsets: list[tuple[float]],
+            later_images_on_top=True,
+            expand_bounds=False,
+            fill_value=0):
+    """
+    Overlay multiple images / image volumes onto each other, with each
+    image offset by a given amount.
+
+    Parameters
+    ----------
+    ims : list of np.ndarray
+        The images or image volumes to overlay.
+
+    offsets : list of tuple of float
+        The offsets to apply to each image volume. Each tuple should
+        have the same length as the number of dimensions in the
+        corresponding images.
+
+    later_images_on_top : bool
+        If True, the later images in the list will be drawn on top of
+        the earlier images. If False, the earlier images will be drawn
+        on top of the later images.
+
+    expand_bounds : bool
+        If True, the output image will be large enough to contain all
+        of the input images. If False, the output image will be the same
+        size as the first input image.
+    """
+    if not len(ims) == len(offsets):
+        raise ValueError('The number of images must match the number of offsets.')
+    ndims = ims[0].ndim
+    if not all([im.ndim == ndims for im in ims[1:]]):
+        raise ValueError('All images must have the same number of dimensions.')
+    if not all([len(offset) == ndims for offset in offsets]):
+        raise ValueError('All offsets must have the same length as the number'
+                         ' of dimensions in the images.')
+
+    if expand_bounds:
+        origin = [min([0] + [offset[axis] for offset in offsets])
+                  for axis in range(ndims)]
+        max_coord = [max([im.shape[axis] + offset[axis]
+                          for im, offset in zip(ims, offsets)])
+                     for axis in range(ndims)]
+        canvas_shape = [max_coord[axis] - origin[axis] for axis in range(ndims)]
+        offsets = [tuple(offset[axis] - origin[axis] for axis in range(ndims))
+                   for offset in offsets]
+        canvas = np.full(canvas_shape, fill_value, dtype=ims[0].dtype)
+    else:
+        canvas = np.full_like(ims[0], fill_value)
+
+    if not later_images_on_top:
+        ims = reversed(ims)
+        offsets = reversed(offsets)
+
+    for im, offset in zip(ims, offsets):
+        paste(im, canvas, offset)
+
+    return canvas
+
+
+def overlay_two_images(im1: np.ndarray,
+                       im2: np.ndarray,
+                       offset: Iterable[float] = 0,
+                       later_images_on_top=True,
+                       expand_bounds=False,
+                       fill_value=0):
+    """
+    Overlay two images, with the second image offset by the given amount.
+    """
+    if isint(offset):
+        offset = [offset] * im1.ndim
+    if expand_bounds:
+        offsets = ([abs(max(0, -o)) for o in offset], [max(0, o) for o in offset])
+    else:
+        offsets = ([0] * len(offset), offset)
+    return overlay([im1, im2],
+                   offsets,
+                   later_images_on_top=later_images_on_top,
+                   expand_bounds=expand_bounds,
+                   fill_value=fill_value)
+
+
+def remove_bleedthrough(im, contaminated_slice, source_slice,
+                        leave_saturated_pixels_alone=True):
+    """
+    Given two channels of multi-channel image, determine how strong the
+    bleedthrough was from the source channel to the contaminated channel
+    and remove the contamination.
+    Saturated pixels are by default not changed, which is reasonable
+    when bleedthrough is weak. If bleedthrough is strong, you may want
+    to try leave_saturated_pixels_alone=False, though this may
+    adjust those pixels more than desired.
+    """
+    #TODO implement ICA and use it to separate the two independent sources
+    raise NotImplementedError
+
+
+def find_landmark(image: np.ndarray,
+                  landmark: np.ndarray,
+                  search_bbox: type = None,
+                  rotation_angles: Iterable = [0]):
+    """
+    Given a region in a source image, find the region in the target
+      image that most resembles the source feature.
+    Specify search_bbox to restrict the search to a particular region
+      within the target image. Otherwise the whole image is searched.
+    By default rotation is not allowed, but specific rotation angles can
+      be searched by passing an iterable specifying rotations (in degrees)
+      to search, e.g.:
+       rotation_angles=[-90, 0, 90]
+       rotation_angles=np.arange(-10, 10.5, 0.5)
+       rotation_angles=np.linspace(-10, 10, 5)
+
+    Implementation leverages cv2.matchTemplate, following tutorial at
+    https://docs.opencv.org/4.5.2/d4/dc6/tutorial_py_template_matching.html
+    """
+    #TODO implement
+    raise NotImplementedError
+
+    if search_bbox is not None:
+        if isinstance(search_bbox[0], slice):
+            img_to_search = image[search_bbox[0], search_bbox[1]]
+        elif isinstance(search_bbox[0], [list, tuple]):
+            img_to_search = image[search_bbox[0][0]:search_bbox[0][1],
+                                  search_bbox[1][0]:search_bbox[1][1]]
+    else:
+        img_to_search = image
+
+    scores = cv2.matchTemplate(img_to_search, landmark, cv2.TM_CCOEFF_NORMED)
+    # TODO TODO TODO implement subpixel max_loc finding. Perhaps fitting a gaussian peak?
+    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(scores)
+    top_left = max_loc  # This is x,y ordered,
+    top_left = top_left[::-1]  # so flip it to y,x
+
+def align(im1, im2, channel=0):
+    """
+    todo
+    """
+    pass

{numpyimage-1.1.1 → numpyimage-1.2.0}/npimage/utils.py

@@ -3,10 +3,10 @@
 import numpy as np
 
 
-def iround(n):
+def iround(n, output_dtype=int):
     # This rounds to the nearest integer, rounding values ending in .5 up
     # (toward positive infinity)
-    return np.floor(n + 0.5).astype(int)
+    return np.floor(n + 0.5).astype(output_dtype)
 
     # "For values exactly halfway between rounded decimal values, NumPy.round
     # rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -0.5 and
@@ -17,12 +17,12 @@ def iround(n):
     #return np.round(n).astype(int)
 
 
-def ifloor(n):
-    return np.floor(n).astype(int)
+def ifloor(n, output_dtype=int):
+    return np.floor(n).astype(output_dtype)
 
 
-def iceil(n):
-    return np.ceil(n).astype(int)
+def iceil(n, output_dtype=int):
+    return np.ceil(n).astype(output_dtype)
 
 
 def eq(a, b, tolerance=1e-8):

numpyimage-1.2.0/numpyimage.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: numpyimage
+Version: 1.2.0
+Summary: Load, save, and manipulate image files as numpy arrays
+Home-page: https://github.com/jasper-tms/npimage
+Author: Jasper Phelps
+Author-email: jasper.s.phelps@gmail.com
+License: GNU GPL v3
+Description: # npimage
+        Need to load pixel values from image files as numpy arrays, and hate having to remember whether you should use PIL, tifffile, matplotlib, or something else? Hate having to deal with the fact that those libraries all use different function names and syntaxes? Wish you could just provide a filename and get back a numpy array? This library's `core.py` does that, with `array = load(filename)`, `save(array, filename)`, and `show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. (Another choice of library to consider for accomplishing similar goals is [imageio](https://pypi.org/project/imageio/), which also supports loading videos through the FFmpeg wrapper library [pyav](https://pypi.org/project/av/).)
+        
+        Want to draw simple shapes like lines, triangles, and circles into 3D numpy arrays? Frustrated that the python libraries you can find online like `opencv` and `skimage.draw` work on 2D arrays but not 3D? I wrote some functions in `graphics.py` that do the trick in 3D. (If you know of another library that can do this, please let me know!)
+        
+        
+        ### Documentation
+        - `core.py`: load, save, or show images.
+        - `graphics.py`: draw points, lines, triangles, circles, or spheres into 2D or 3D numpy arrays representing image volumes.
+        - `nrrd_utils.py`: compress or read metadata from `.nrrd` files.
+        - `operations.py`: perform operations on images.
+        
+        For now, check each function's docstring for more. A jupyter notebook demonstrating this package's functions will come later.
+        
+        
+        ### Installation
+        
+        As is always the case in python, consider making a virtual environment (using your preference of conda, virtualenv, or virtualenvwrapper) before installing.
+        
+        **Option 1:** `pip install` from PyPI:
+        
+            pip install numpyimage
+        
+        (Unfortunately the name `npimage` was already taken on PyPI, so `pip install npimage` will get you a different package.)
+        
+        **Option 2:** `pip install` directly from GitHub:
+            
+            pip install git+https://github.com/jasper-tms/npimage.git
+        
+        **Option 3:** First `git clone` this repo and then `pip install` it from your clone:
+        
+            cd ~/repos  # Or wherever on your computer you want to download this code to
+            git clone https://github.com/jasper-tms/npimage.git
+            cd npimage
+            pip install .
+        
+        **After installing,** you can import this package in python using `import npimage` (not `import numpyimage`!)
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

{numpyimage-1.1.1 → numpyimage-1.2.0}/numpyimage.egg-info/requires.txt

@@ -3,3 +3,4 @@ pillow
 tifffile
 pynrrd
 matplotlib
+opencv-python

{numpyimage-1.1.1 → numpyimage-1.2.0}/requirements.txt

@@ -3,3 +3,4 @@ pillow
 tifffile
 pynrrd
 matplotlib
+opencv-python

{numpyimage-1.1.1 → numpyimage-1.2.0}/setup.py

@@ -9,7 +9,7 @@ with open("requirements.txt", "r") as f:
 
 setuptools.setup(
     name="numpyimage",
-    version="1.1.1",
+    version="1.2.0",
     author="Jasper Phelps",
     author_email="jasper.s.phelps@gmail.com",
     description="Load, save, and manipulate image files as numpy arrays",
@@ -18,7 +18,6 @@ setuptools.setup(
     url="https://github.com/jasper-tms/npimage",
     license='GNU GPL v3',
     packages=setuptools.find_packages(),
-    #package_data={'npimage': ['requirements.txt']},
     classifiers=[
         "Programming Language :: Python :: 3",
         'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',

numpyimage-1.1.1/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.1
-Name: numpyimage
-Version: 1.1.1
-Summary: Load, save, and manipulate image files as numpy arrays
-Home-page: https://github.com/jasper-tms/npimage
-Author: Jasper Phelps
-Author-email: jasper.s.phelps@gmail.com
-License: GNU GPL v3
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# npimage
-Need to load pixel values from image files as numpy arrays, and hate having to remember whether you should use PIL, tifffile, matplotlib, or something else? Hate having to deal with the fact that those libraries all use different function names and syntaxes? Wish you could just provide a filename and get back a numpy array? This library's `core.py` does that, with `array = load(filename)`, `save(array, filename)`, and `show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. (Another choice of library to consider for accomplishing similar goals is [imageio](https://pypi.org/project/imageio/), which also supports loading videos through the FFmpeg wrapper library [pyav](https://pypi.org/project/av/).)
-
-Want to draw simple shapes like lines, triangles, and circles into 3D numpy arrays? Frustrated that the python libraries you can find online like `opencv` and `skimage.draw` work on 2D arrays but not 3D? I wrote some functions in `graphics.py` that do the trick in 3D. (If you know of another library that can do this, please let me know!)
-
-
-### Documentation
-- `core.py`: load, save, or show images.
-- `graphics.py`: draw points, lines, triangles, circles, or spheres into 2D or 3D numpy arrays representing image volumes.
-- `nrrd_utils.py`: compress or read metadata from `.nrrd` files.
-- `operations.py`: perform operations on images.
-
-For now, check each function's docstring for more. A jupyter notebook demonstrating this package's functions will come later.
-
-
-### Installation
-
-As is always the case in python, consider making a virtual environment (using your preference of conda, virtualenv, or virtualenvwrapper) before installing.
-
-**Option 1:** `pip install` from PyPI:
-
-    pip install numpyimage
-
-(Unfortunately the name `npimage` was already taken on PyPI, so `pip install npimage` will get you a different package.)
-
-**Option 2:** `pip install` directly from GitHub:
-    
-    pip install git+https://github.com/jasper-tms/npimage.git
-
-**Option 3:** First `git clone` this repo and then `pip install` it from your clone:
-
-    cd ~/repos  # Or wherever on your computer you want to download this code to
-    git clone https://github.com/jasper-tms/npimage.git
-    cd npimage
-    pip install .
-
-**After installing,** you can import this package in python using `import npimage` (not `import numpyimage`!)

numpyimage-1.1.1/npimage/operations.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-
-from collections.abc import Iterable
-
-import numpy as np
-
-from .utils import iround, eq, isint
-
-
-def to_8bit(image: np.ndarray,
-            bottom_percentile=0.4,
-            top_percentile=99.6,
-            bottom_value=None,
-            top_value=None) -> np.ndarray:
-    """
-    Convert an image to 8-bit (uint8) by scaling the image's pixel values so
-    that values <= bottom_value are mapped to 0 and values >= top_value are
-    mapped to 255. Values within the range (bottom_value, top_value) will be
-    mapped linearly into the range [1, 254]. By default, bottom_value and
-    top_value are set to percentiles of the source image's pixel values.
-    Some examples:
-    - Set bottom_percentile=0 to map only the minimum value in the source image
-      to 0 and and top_percentile=100 to map only the maximum value in the
-      source image to 255, and all other values to the range [1, 254].
-    - Set bottom_percentile=25 to map all of the the lowest 25% of the source
-      image's pixel values to 0 and set top_percentile=75 to map all of the
-      highest 25% of the source image's pixel values to 255.
-    The defaults are:
-    - bottom_percentile=0.4 (~= 100*1/256)
-    - top_percentile=99.6 (~= 100*255/256)
-    to map the bottom 1/256th of the pixel values to 0 and the top 1/256th of
-    the pixel values to 255. (Compared to using percentiles of 0 and 100, this
-    approach lessens the impact of a few extreme outlier pixel values in the
-    image.)
-
-    You may however specify bottom_value and/or top_value explicitly yourself,
-    in which case bottom_percentile and/or top_percentile will be ignored.
-
-    Algorithm:
-    - Clip values < bottom_value or > top_value
-      (i.e. replace them with bottom_value or top_value)
-    - Map the range [bottom_value, top_value] to
-      [just less than 1, just greater than 255]
-    - Cast to int (which rounds down)
-    From these two steps, values will be transformed as follows:
-    - bottom_value or less -> just less than 1 -> 0
-    - a value just greater than bottom_value -> just greater than 1 -> 1
-    - top_value or larger -> just greater than 255 -> 255
-    - a value just less than top_value -> just less than 255 -> 254
-    - values between bottom_value and top_value -> linearly mapped to
-      values between 1 and 254
-    """
-    assert isinstance(image, np.ndarray)
-
-    if bottom_value is None or top_value is None:
-        percentiles = np.percentile(image, [bottom_percentile, top_percentile])
-    if bottom_value is None:
-        bottom_value = percentiles[0]
-    if top_value is None:
-        top_value = percentiles[1]
-
-    if bottom_value == top_value:
-        raise ZeroDivisionError('top_value and bottom_value are the same: '
-                                '{}'.format(top_value))
-
-    image = np.clip(image, bottom_value, top_value)
-
-    bottom_target = 1 - 1e-12
-    top_target = 255 + 1e-12
-    return ((image.astype('float64') - bottom_value)
-            / (top_value - bottom_value)
-            * (top_target - bottom_target)
-            + bottom_target).astype('uint8')
-
-
-def offset(image: np.ndarray,
-           distance: Iterable,
-           fill_value=0,
-           fill_transparent=False) -> np.ndarray:
-    """
-    Offset an image by a given distance.
-
-    'distance' must be an iterable with length matching the number of axes in
-    the image, to specify an number of pixels to offset along each axis. If the
-    image is rgb or rgba (that is, the final axis has length 3 or 4), it is not
-    necessary to specify an offset for that axis and so the 'distance' iterable
-    can be one element shorter than the number of axes in the image.
-
-    The pixels no longer occupied by the original image as a result of the
-    offset will be filled in with 'fill_value'.
-
-    See also scipy.ndimage.shift, which performs a very similar operation
-    """
-    if len(image.shape) == len(distance) + 1 and image.shape[-1] in [3, 4]:
-        # Specify no offset along the channels axis, if not specified by user
-        distance = (*distance, 0)
-
-    if len(image.shape) != len(distance):
-        m = (f'distance must have length {len(image.shape)} to specify an'
-             ' offset along each axis of the image, but instead had length'
-             f' {len(distance)}')
-        raise ValueError(m)
-
-    new_image = np.full_like(image, fill_value)  # Blank image filled with fill_value
-    if image.shape[-1] == 4 and not fill_transparent:
-        # If rgba, set alpha channel value to max
-        # The line below means new_image[:, :, :, ..., :, -1] = 255
-        new_image[tuple([slice(None, None)] * (len(image.shape)-1) + [-1])] = 255
-
-    distance_int = [int(x) for x in distance]
-
-    source_range = [slice(max(0, -d), min(s, s-d)) for d, s in zip(distance_int, image.shape)]
-    target_range = [slice(max(0, d), min(s, s+d)) for d, s in zip(distance_int, image.shape)]
-
-    new_image[tuple(target_range)] = image[tuple(source_range)]
-
-    for i, d in enumerate(distance):
-        if not eq(d, int(d)):
-            _offset_subpixel(new_image, d - int(d), i, fill_value=fill_value,
-                             fill_transparent=fill_transparent, inplace=True)
-
-    return new_image
-
-
-def _offset_subpixel(image: np.ndarray,
-                     distance: float,
-                     axis: int,
-                     fill_value=0,
-                     fill_transparent=False,
-                     inplace=False):
-    """
-    Offset an image by a fraction of a pixel along a single specified axis.
-
-    If an offset of 0.1 is requested, the output will be 10% of the image
-    shifted one pixel upward plus 90% of the original image.
-    If an offset of -0.1 is requested, the output will be 10% of the image
-    shifted one pixel downward plus 90% of the original image.
-    If an offset of 0.5 is requested, the output will be 50% of the image
-    shifted one pixel upward plus 50% of the original image.
-    etc.
-
-    The pixels no longer occupied by the original image as a result of the
-    offset will be filled in with 'fill_value'.
-    """
-    assert -1 < distance and distance < 1
-
-    one_pix_offset = [0] * len(image.shape)
-    one_pix_offset[axis] = 1 if distance >= 0 else -1
-    image_1pix_shifted = offset(image, one_pix_offset, fill_value=fill_value,
-                                fill_transparent=fill_transparent)
-    distance = abs(distance)
-
-    image_subpix_shifted = image * (1 - distance) + image_1pix_shifted * distance
-    if np.issubdtype(image.dtype, np.integer):
-        image_subpix_shifted = iround(image_subpix_shifted)
-
-    if inplace:
-        image[:] = image_subpix_shifted
-    else:
-        return image_subpix_shifted
-
-
-def remove_bleedthrough(im, contaminated_slice, source_slice,
-                        leave_saturated_pixels_alone=True):
-    """
-    Given two channels of multi-channel image, determine how strong the
-    bleedthrough was from the source channel to the contaminated channel
-    and remove the contamination.
-    Saturated pixels are by default not changed, which is reasonable
-    when bleedthrough is weak. If bleedthrough is strong, you may want
-    to try leave_saturated_pixels_alone=False, though this may
-    adjust those pixels more than desired.
-    """
-    #TODO implement ICA and use it to separate the two independent sources
-    raise NotImplementedError
-
-
-def find_landmark(im1, landmark_bbox,
-                  im2, search_bbox=None,
-                  rotation_angles=[0]):
-    """
-    Given a region in a source image, find the region in the target
-      image that most resembles the source feature.
-    Specify search_bbox to restrict the search to a particular region
-      within the target image. Otherwise the whole image is searched.
-    By default rotation is not allowed, but specific rotation angles can
-      be searched by passing an iterable specifying rotations (in degrees)
-      to search, e.g.:
-       rotation_range=[-90, 0, 90]
-       rotation_range=np.arange(-10, 10.5, 0.5)
-       rotation_range=np.linspace(-10, 10, 5)
-
-    See also cv2.matchTemplate, e.g. https://docs.opencv.org/4.5.2/d4/dc6/tutorial_py_template_matching.html
-    """
-    #TODO implement
-    raise NotImplementedError

numpyimage-1.1.1/numpyimage.egg-info/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.1
-Name: numpyimage
-Version: 1.1.1
-Summary: Load, save, and manipulate image files as numpy arrays
-Home-page: https://github.com/jasper-tms/npimage
-Author: Jasper Phelps
-Author-email: jasper.s.phelps@gmail.com
-License: GNU GPL v3
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# npimage
-Need to load pixel values from image files as numpy arrays, and hate having to remember whether you should use PIL, tifffile, matplotlib, or something else? Hate having to deal with the fact that those libraries all use different function names and syntaxes? Wish you could just provide a filename and get back a numpy array? This library's `core.py` does that, with `array = load(filename)`, `save(array, filename)`, and `show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. (Another choice of library to consider for accomplishing similar goals is [imageio](https://pypi.org/project/imageio/), which also supports loading videos through the FFmpeg wrapper library [pyav](https://pypi.org/project/av/).)
-
-Want to draw simple shapes like lines, triangles, and circles into 3D numpy arrays? Frustrated that the python libraries you can find online like `opencv` and `skimage.draw` work on 2D arrays but not 3D? I wrote some functions in `graphics.py` that do the trick in 3D. (If you know of another library that can do this, please let me know!)
-
-
-### Documentation
-- `core.py`: load, save, or show images.
-- `graphics.py`: draw points, lines, triangles, circles, or spheres into 2D or 3D numpy arrays representing image volumes.
-- `nrrd_utils.py`: compress or read metadata from `.nrrd` files.
-- `operations.py`: perform operations on images.
-
-For now, check each function's docstring for more. A jupyter notebook demonstrating this package's functions will come later.
-
-
-### Installation
-
-As is always the case in python, consider making a virtual environment (using your preference of conda, virtualenv, or virtualenvwrapper) before installing.
-
-**Option 1:** `pip install` from PyPI:
-
-    pip install numpyimage
-
-(Unfortunately the name `npimage` was already taken on PyPI, so `pip install npimage` will get you a different package.)
-
-**Option 2:** `pip install` directly from GitHub:
-    
-    pip install git+https://github.com/jasper-tms/npimage.git
-
-**Option 3:** First `git clone` this repo and then `pip install` it from your clone:
-
-    cd ~/repos  # Or wherever on your computer you want to download this code to
-    git clone https://github.com/jasper-tms/npimage.git
-    cd npimage
-    pip install .
-
-**After installing,** you can import this package in python using `import npimage` (not `import numpyimage`!)