numpyimage 2.1.1__tar.gz → 2.2.0__tar.gz

{numpyimage-2.1.1 → numpyimage-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 2.1.1
+Version: 2.2.0
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/__init__.py

@@ -1,4 +1,7 @@
+#!/usr/bin/env python3
+
 from .core import *
 from .operations import *
 from .align import *
 from .graphics import *
+from .utils import *

numpyimage-2.2.0/npimage/align.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Functions for aligning images.
+"""
+from typing import Optional, Tuple, Literal
+
+import numpy as np
+import cv2 as cv
+
+
+def find_landmark(image: np.ndarray,
+                  landmark: np.ndarray,
+                  search_bbox: Optional[Tuple[Tuple[int, int], Tuple[int, int]]] = None,
+                  metric: Literal[cv.TM_SQDIFF, cv.TM_SQDIFF_NORMED,
+                                  cv.TM_CCORR, cv.TM_CCORR_NORMED,
+                                  cv.TM_CCOEFF, cv.TM_CCOEFF_NORMED] = cv.TM_CCOEFF_NORMED,
+                  subpixel_accuracy: bool = True
+                  ) -> Tuple[Tuple[int, int], float]:
+    """
+    Find the region in an image that most resembles a particular landmark.
+
+    Implementation leverages OpenCV functions, following tutorial at
+    https://docs.opencv.org/4.x/d4/dc6/tutorial_py_template_matching.html
+
+    Parameters
+    ----------
+    image : np.ndarray
+        The image in which to search for the landmark.
+
+    landmark : np.ndarray
+        The landmark to search for in the image.
+
+    search_bbox : ([axis1min, axis1max], [axis2min, axis2max])
+        The bounding box in which to search for the landmark. If you know
+        the landmark you're searching for is in a subset of the image then
+        specifying a search region will save time.
+        If None, the entire image will be searched. If not None, search_bbox
+        should be a list/tuple with two elements. Each element should be either
+        a slice object or a list/tuple of two integers that specify the min and
+        max values of the range.
+        For example, search_bbox=(slice(0, 100), slice(0, 200)) or
+        search_box=([0, 100], [0, 200]) would search the top-left
+        100x200 region of the image.
+
+    metric : cv.TemplateMatchModes, optional
+        The metric to use to compare the landmark to the image. Options are
+        cv.TM_SQDIFF, cv.TM_SQDIFF_NORMED, cv.TM_CCORR, cv.TM_CCORR_NORMED,
+        cv.TM_CCOEFF, cv.TM_CCOEFF_NORMED. Default is cv.TM_CCOEFF_NORMED.
+
+    Returns
+    -------
+    (top_left, match_score) : tuple
+        top_left : tuple
+            The top-left corner of the bounding box in the image that
+            is most similar to the landmark.
+        score : float
+            The score of the match, from 0 to 1. A score of 1 indicates
+            a perfect match.
+    """
+    if search_bbox is not None:
+        if all(isinstance(el, slice) for el in search_bbox):
+            img_to_search = image[search_bbox[0], search_bbox[1]]
+            search_offset = (search_bbox[0].start, search_bbox[1].start)
+        elif all(isinstance(el, (list, tuple)) and len(el) == 2
+                 for el in search_bbox):
+            img_to_search = image[search_bbox[0][0]:search_bbox[0][1],
+                                  search_bbox[1][0]:search_bbox[1][1]]
+            search_offset = (search_bbox[0][0], search_bbox[1][0])
+        else:
+            raise ValueError(f"Invalid search_bbox: {search_bbox}. Must "
+                             "be two slices or two (min, max) pairs.")
+    else:
+        img_to_search = image
+        search_offset = (0, 0)
+
+    # Perform template matching
+    scores = cv.matchTemplate(img_to_search, landmark, metric)
+
+    min_val, max_val, min_loc, max_loc = cv.minMaxLoc(scores)
+    if metric in [cv.TM_SQDIFF, cv.TM_SQDIFF_NORMED]:
+        top_left = min_loc[::-1]  # Includes a flip from (x, y) to (y, x)
+        match_score = 1 - min_val
+    else:
+        top_left = max_loc[::-1]  # Includes a flip from (x, y) to (y, x)
+        match_score = max_val
+
+    if not subpixel_accuracy:
+        top_left = (top_left[0] + search_offset[0],
+                    top_left[1] + search_offset[1])
+        return top_left, match_score
+
+    # Subpixel accuracy: Fit a quadratic to a patch around the best score
+    patch_size = 5
+    patch_top_left = (max(0, top_left[0] - patch_size//2),
+                      max(0, top_left[1] - patch_size//2))
+    patch_bottom_right = (min(scores.shape[0], top_left[0] + patch_size//2),
+                          min(scores.shape[1], top_left[1] + patch_size//2))
+    patch = scores[patch_top_left[0]:patch_bottom_right[0],
+                   patch_top_left[1]:patch_bottom_right[1]]
+
+    def eval_quadratic(coeffs, x, y):
+        """
+        Evaluate a quadratic surface at a given point.
+
+        The quadratic surface is defined as:
+            quadratic(x, y) = a*x**2 + b*y**2 + c*x*y + d*x + e*y + f
+        """
+        a, b, c, d, e, f = coeffs
+        return a*x**2 + b*y**2 + c*x*y + d*x + e*y + f
+
+    def quadratic_interpolate_peak(patch):
+        """
+        Fit a 2D quadratic surface to a matrix of values, and find
+        the peak position and value of the surface.
+
+        Returns
+        -------
+        tuple containing
+        - The coordinate of the peak value of the quadratic fit to the patch
+        - The peak value
+        """
+        A = [[i**2, j**2, i*j, i, j, 1] for i, j in np.ndindex(patch.shape)]
+        z = [patch[i, j] for i, j in np.ndindex(patch.shape)]
+        A = np.array(A)
+        z = np.array(z)
+
+        coeffs, *_ = np.linalg.lstsq(A, z, rcond=None)
+        a, b, c, d, e, f = coeffs
+
+        # Find peak by solving gradient = 0:
+        # df/di = 2a i + c j + d = 0
+        # df/dj = 2b j + c i + e = 0
+        A_grad = np.array([[2*a, c],
+                           [c, 2*b]])
+        b_grad = -np.array([d, e])
+        try:
+            peak_loc = np.linalg.solve(A_grad, b_grad)
+        except np.linalg.LinAlgError:
+            peak_loc = np.array([np.nan, np.nan])  # singular matrix, fallback
+
+        peak_value = eval_quadratic(coeffs, peak_loc[0], peak_loc[1])
+        return peak_loc, peak_value
+
+    patch_peak, peak_value = quadratic_interpolate_peak(patch)
+    image_peak = patch_peak + patch_top_left + search_offset
+    image_peak = (round(image_peak[0], ndigits=2),
+                  round(image_peak[1], ndigits=2))
+
+    return image_peak, peak_value

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/core.py

@@ -9,6 +9,7 @@ Function list:
 - show(np_array) -> Displays a numpy array of pixel values as an image
 """
 
+from typing import Literal
 import os
 import glob
 from builtins import open as builtin_open
@@ -76,7 +77,24 @@ def load(filename, dim_order='zyx', **kwargs):
         if 'shape' in kwargs:
             data = data.reshape(*kwargs['shape'])
 
+    if extension == 'ng':
+        from cloudvolume import CloudVolume
+        if '://' not in filename:
+            filename = 'file://' + filename
+        vol = CloudVolume(filename)
+        data = np.array(vol[:]).squeeze()
+        # CloudVolume is unusual in returning data in Fortran order,
+        # so we transpose xyz -> zyx
+        data = data.T
+        metadata = utils.transpose_metadata(vol.info, inplace=False)
+
     if extension == 'zarr':
+        if '.ome.zarr' in filename:
+            import ome_zarr.io.parse_url
+            import ome_zarr.reader.Reader
+            raise NotImplementedError
+            return 'something something'
+
         if 'dataset' not in kwargs:
             dataset = filename + '/'
             while (not os.path.exists(os.path.join(dataset, '.zarray')) and
@@ -94,23 +112,18 @@ def load(filename, dim_order='zyx', **kwargs):
                 raise Exception(f'Multiple datasets found within {filename}.'
                                 ' Pass a "dataset=" argument to specify the'
                                 ' one you want.')
+        raise NotImplementedError('Reading Zarr format not yet implemented.')
+        #import zarr
+        #data = zarr.open(TODO) #Finish this and be sure to check zyx/xyz order
 
-        try:
-            import daisy
-        except:
-            daisy = None
-
-        if daisy:
-            data = daisy.open_ds(filename, dataset)[:] #TODO check zyx/xyz order. Pretty sure daisy zarrs are zyx
-        else:
-            raise NotImplementedError
-            import zarr
-            data = zarr.open(TODO) #TODO check zyx/xyz order
+    if data is None:
+        raise ValueError(f'Could not read file {filename}. '
+                         'Please check the file format and try again.')
 
     if 'xy' in dim_order:
         data = data.T
-        if extension == 'nrrd':  # TODO check if other formats need this
-            utils.transpose_metadata(metadata, inplace=True)
+        if extension in ['nrrd', 'ng']:
+            metadata = utils.transpose_metadata(metadata, inplace=False)
 
     if any([kwargs.get(key, False) for key in
             ['metadata', 'get_metadata', 'return_metadata']]):
@@ -153,10 +166,10 @@ def save(data,
     if os.path.exists(filename) and not overwrite:
         raise FileExistsError(f'File {filename} already exists. '
                               'Set overwrite=True to overwrite.')
-    extension = filename.split('.')[-1]
+    extension = filename.split('.')[-1].lower()
     assert extension in supported_extensions, f'Filetype {extension} not supported'
 
-    if compress and extension not in ['nrrd', 'ng']:
+    if compress is not None and extension not in ['nrrd', 'ng']:
         print('WARNING: compress argument is ignored because not saving as '
               '.nrrd. Whether or not compression occurs now will depend on '
               'the format you are saving to.')
@@ -194,9 +207,15 @@ def save(data,
             metadata = metadata.copy()
         custom_field_map = {}
 
-        if compress is True:
+        if compress is True or compress in ['lossless', 'gzip']:
             metadata.update({'encoding': 'gzip'})
-        if compress is False or 'encoding' not in metadata:
+        elif compress is False:
+            metadata.update({'encoding': 'raw'})
+        elif compress is not None:
+            raise ValueError('For .nrrd format, compress must be '
+                             'True/"lossless"/"gzip", or False,'
+                             f' but was "{compress}"')
+        if 'encoding' not in metadata:
             metadata.update({'encoding': 'raw'})
 
         if isinstance(metadata.get('space directions', None), str):
@@ -218,7 +237,7 @@ def save(data,
                     pixel_size = [pixel_size] * data.ndim
             if len(pixel_size) != data.ndim:
                 raise ValueError(f'pixel_size has length {len(pixel_size)},'
-                                 ' but data has {data.ndim} dimensions.')
+                                 f' but data has {data.ndim} dimensions.')
 
             pixel_size_not_none = [size for size in pixel_size
                                    if size is not None and size != np.nan]
@@ -231,13 +250,7 @@ def save(data,
             metadata.update({'space directions': space_directions})
 
         if 'space dimension' not in metadata and 'space' not in metadata:
-            # If the number of spatial dimensions is not specified, assume
-            # it's the number of dimensions in the data array, minus 1 if
-            # a channel axis is present.
-            if find_channel_axis(data) is not None:
-                metadata.update({'space dimension': data.ndim - 1})
-            else:
-                metadata.update({'space dimension': data.ndim})
+            metadata.update({'space dimension': data.ndim})
         if units is not None:
             if hasattr(units, '__iter__') and not isinstance(units, str):
                 units = list(units)
@@ -339,13 +352,30 @@ write = save  # Function name alias
 to_file = save  # Function name alias
 
 
-def save_video(data, filename, overwrite=False, dim_order='yx', time_axis=0,
+def save_video(data, filename, time_axis=0, overwrite=False, dim_order='yx',
                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
+
+    Parameters
+    ----------
+    data : numpy.ndarray or list of filenames
+        A 3D numpy array of pixel values.
+
+    filename : str
+        The filename to save the video to.
+
+    time_axis : int, default 0
+        The axis of the data array that will be played as time in the video.
+
+    overwrite : bool, default False
+        Whether to overwrite the file if it already exists.
+
+    dim_order : 'yx' (default) or 'xy'
+        The order of the spatial dimensions in the input data.
     """
     if not data.ndim == 3:
         raise ValueError('Input data must be a 3D numpy array.')
@@ -359,13 +389,22 @@ def save_video(data, filename, overwrite=False, dim_order='yx', time_axis=0,
         data = data.swapaxes(1, 2)
     n_frames = data.shape[0]
 
-    if filename.split('.')[-1] not in ['mp4', 'mkv', 'avi', 'mov']:
+    if filename.split('.')[-1].lower() not in ['mp4', 'mkv', 'avi', 'mov']:
         filename += '.mp4'
     if os.path.exists(filename) and not overwrite:
         raise FileExistsError(f'File {filename} already exists. '
                               'Set overwrite=True to overwrite.')
-    container = av.open(filename, mode='w')
+    extension = filename.split('.')[-1].lower()
+    if extension == 'mp4':
+        pad = [[0, 0], [0, 0], [0, 0]]
+        if data.shape[1] % 2 != 0:
+            pad[1][1] = 1
+        if data.shape[2] % 2 != 0:
+            pad[2][1] = 1
+        if pad != [[0, 0], [0, 0], [0, 0]]:
+            data = np.pad(data, pad, mode='edge')
 
+    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}
@@ -385,8 +424,10 @@ def save_video(data, filename, overwrite=False, dim_order='yx', time_axis=0,
 
 def show(data,
          dim_order='yx',
-         mode='PIL',
+         data_type: Literal['image', 'segmentation'] = 'image',
+         mode: Literal['PIL', 'mpl'] = 'PIL',
          convert_to_8bit=True,
+         channel_axis='guess',
          **kwargs):
     """
     Display a numpy array of pixel values as an image. Supported types:
@@ -410,6 +451,9 @@ def show(data,
         if os.path.exists(data):
             data = load(data)
 
+    if data_type == 'segmentation':
+        data = utils.assign_random_colors(data, seed=kwargs.get('seed', None))
+
     if (not data.ndim == 2) and not (data.ndim == 3 and find_channel_axis(data) is not None):
         m = ('Data must have shape (y, x) for grayscale, '
              '(y, x, 3) for RGB, or (y, x, 4) for RGBA but had '
@@ -420,8 +464,9 @@ def show(data,
 
     if 'xy' in dim_order:
         data = data.T
-    channel_axis = find_channel_axis(data, expected_channel_axis=-1)
-    if channel_axis is not None and channel_axis != -1:
+    if channel_axis == 'guess':
+        channel_axis = find_channel_axis(data)
+    if utils.isint(channel_axis) and channel_axis != -1:
         data = np.moveaxis(data, find_channel_axis(data), -1)
 
     if convert_to_8bit and data.dtype != np.uint8:
@@ -480,6 +525,7 @@ def find_channel_axis(data, expected_channel_axis=[0, -1]):
         Note that returning 0 means the channel axis was found and is the first
         axis, so be careful not to do a test like `if find_channel_axis(data):`
         because 0 will evaluate to False even though the data has a channel axis.
+        Instead write `if find_channel_axis(data) is not None:`
     """
     if isinstance(expected_channel_axis, int):
         expected_channel_axis = [expected_channel_axis]

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/filetypes/pbm.py

@@ -19,14 +19,18 @@ def load(filename):
         while line.startswith(b'#'):  # Print and skip comments
             print(line.decode().strip('\n'))
             line = f.readline()
-        w, h = line.decode().strip().split()
-        w = int(w)
-        h = int(h)
-        data = f.readline()
-        data = np.unpackbits(np.frombuffer(data, dtype=np.uint8))
-        data = data.reshape((h, w)).view(bool)
+        line = line.decode().strip().split()
+        w = int(line[0])
+        h = int(line[1])
 
-    return data
+        # Calculate the number of bytes per row (padded to the next byte boundary)
+        row_bytes = (w + 7) // 8
+        data = np.frombuffer(f.read(row_bytes * h), dtype=np.uint8)
+
+        # Unpack bits and reshape, then slice to remove padding bits
+        data = np.unpackbits(data).reshape((h, row_bytes * 8))[:, :w]
+
+    return data.astype(bool)
 
 
 def save(data, filename, comments=None):
@@ -62,4 +66,38 @@ def save(data, filename, comments=None):
         f.write(b'\n')
 
         # Data
-        f.write(np.packbits(data).tobytes())
+        # Pad each row to the next byte boundary
+        row_bytes = (data.shape[1] + 7) // 8
+        padded_data = np.zeros((data.shape[0], row_bytes * 8), dtype=bool)
+        padded_data[:, :data.shape[1]] = data
+        f.write(np.packbits(padded_data).tobytes())
+
+
+def predict_file_size(data: np.ndarray) -> int:
+    """
+    Predict the file size of a PBM file given the image data.
+
+    Parameters
+    ----------
+    data : np.ndarray
+        The image data as a numpy array.
+
+    Returns
+    -------
+    int
+        The predicted file size in bytes.
+    """
+    if not isinstance(data, np.ndarray):
+        raise TypeError('data must be a np.ndarray but was {}'.format(type(data)))
+
+    # Header: 'P4\n' (3 bytes)
+    header_size = 3
+
+    # Dimensions: '<width> <height>\n'
+    dimensions_size = len(f"{data.shape[1]} {data.shape[0]}\n")
+
+    # Data: Each row is padded to the next byte boundary
+    row_bytes = (data.shape[1] + 7) // 8
+    data_size = row_bytes * data.shape[0]
+
+    return header_size + dimensions_size + data_size

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/graphics.py

@@ -51,7 +51,7 @@ import itertools
 import numpy as np
 np.set_printoptions(suppress=True)
 
-from .utils import eq, ifloor, iceil, iround
+from .utils import eq, ifloor, iceil, iround, is_out_of_bounds, remove_out_of_bounds
 
 
 # --- Primitive shapes - points, lines, triangles, circles, spheres --- #
@@ -358,40 +358,28 @@ def imget(image, coords, convention='corner',
     makes more sense in most graphics applications.
         out_of_bounds, string   : 'ignore' (default), 'wrap', or 'raise'
     """
-    assert convention in ['corner', 'center']
     if not isinstance(coords, np.ndarray):
         coords = np.array(coords)
-    ax = len(coords.shape) - 1
-
-    if convention == 'corner':
-        is_negative = coords < 0
-        exceeds_dimensions = coords >= image.shape
-    elif convention == 'center':
-        is_negative = coords < -0.5
-        exceeds_dimensions = coords + 0.5 >= image.shape
-
-    is_out_of_bounds = np.logical_or(is_negative, exceeds_dimensions)
-    if (is_out_of_bounds).any():
-        def warn():
+    n_original = coords.shape[0]
+
+    if out_of_bounds == 'wrap':
+        allow_negative_wrapping = True
+    elif out_of_bounds == 'ignore':
+        allow_negative_wrapping = False
+    elif out_of_bounds != 'raise':
+        raise ValueError("out_of_bounds must be 'ignore', 'raise', or"
+                         f"'wrap' but was {out_of_bounds}.")
+    coords = remove_out_of_bounds(coords, image.shape, allow_negative_wrapping, convention)
+    if n_original > coords.shape[0]:
+        n_out_of_bounds = n_original - coords.shape[0]
+        if out_of_bounds == 'raise':
+            raise IndexError(f'{n_out_of_bounds}/{n_original} coordinates'
+                             'are out of bounds.')
+        if verbose:
             print('WARNING: Some requested coordinates are out of bounds.'
                   ' The returned list of values will be shorter than the'
                   ' request list, and therefore the returned values will not'
                   ' match 1-to-1 with the requested coordinates.')
-        if out_of_bounds == 'ignore':
-            coords = coords[~is_out_of_bounds.any(axis=ax)]
-            if verbose:
-                print(f'verbose={verbose}')
-                warn()
-        elif out_of_bounds == 'wrap':
-            coords = coords[~exceeds_dimensions.any(axis=ax)]
-            if verbose:
-                warn()
-        elif out_of_bounds == 'raise':
-            raise IndexError('Some coordinates out of bounds:\n'
-                             f'{coords[is_out_of_bounds]}')
-        else:
-            raise ValueError("out_of_bounds must be 'ignore', 'raise', or"
-                             f"'wrap' but was {out_of_bounds}.")
 
     if convention == 'corner':
         return image[tuple(ifloor(coords).T)]
@@ -409,26 +397,20 @@ def imset(image, coords, value, convention='corner', out_of_bounds='ignore'):
     makes more sense in most graphics applications.
         out_of_bounds, string   : 'ignore' (default), 'wrap', or 'raise'
     """
-    assert convention in ['corner', 'center']
     if not isinstance(coords, np.ndarray):
         coords = np.array(coords)
 
-    if convention == 'corner':
-        is_negative = coords < 0
-        exceeds_dimensions = coords >= image.shape
-    else:  # convention == 'center'
-        is_negative = coords < -0.5
-        exceeds_dimensions = coords + 0.5 >= image.shape
-
-    is_out_of_bounds = np.logical_or(is_negative, exceeds_dimensions)
-    if (is_out_of_bounds).any():
-        if out_of_bounds == 'ignore':
-            coords = coords[~is_out_of_bounds.any(axis=1)]
-        elif out_of_bounds == 'wrap':
-            coords = coords[~exceeds_dimensions.any(axis=1)]
+    if out_of_bounds == 'wrap':
+        allow_negative_wrapping = True
+    else:
+        allow_negative_wrapping = False
+    is_oob = is_out_of_bounds(coords, image.shape, allow_negative_wrapping, convention)
+    if is_oob.any():
+        if out_of_bounds in ['ignore', 'wrap']:
+            coords = coords[~is_oob]
         elif out_of_bounds == 'raise':
             raise IndexError('Some coordinates out of bounds:\n'
-                             f'{coords[is_out_of_bounds]}')
+                             f'{coords[is_oob]}')
         else:
             raise ValueError("out_of_bounds must be 'ignore', 'raise', or"
                              f"'wrap' but was {out_of_bounds}.")
@@ -642,8 +624,8 @@ def get_voxels_within_distance(distance, center=None, ndims=None,
     }
     d = norms[metric]
 
-    candidate_pts_scaled = candidate_pts * voxel_size
-    return candidate_pts[d(candidate_pts_scaled) <= distance] + center
+    candidate_pts_scaled = candidate_pts * voxel_size / distance
+    return candidate_pts[d(candidate_pts_scaled) <= 1] + center
 
 
 def floodfill(image, seed, fill_value, fill_diagonally=False,

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/operations.py

@@ -19,6 +19,37 @@ import numpy as np
 from .utils import iround, eq, isint
 
 
+def squeeze_dtype(image: np.ndarray):
+    """
+    Cast a numpy array to the smallest possible dtype without losing information.
+    """
+    if not isinstance(image, np.ndarray):
+        raise TypeError('image must be a numpy array')
+
+    im_has_fractions = not np.all(image == np.floor(image))
+    if im_has_fractions:
+        candidates = [np.float16, np.float32, np.float64]
+        # TODO some logic
+        print('WARNING: squeeze_dtype not fully implemented on float values,'
+              ' returning original data unchanged.')
+        return image
+    elif image.min() < 0:
+        candidates = [np.int8, np.int16, np.int32, np.int64]
+    elif image.max() <= 1:
+        return image.astype(bool, copy=False)
+    else:
+        candidates = [np.uint8, np.uint16, np.uint32, np.uint64]
+
+    image_max = image.max()
+    if image_max <= 1:
+        return image.astype(bool, copy=False)
+    for dtype in candidates:
+        info = np.iinfo(dtype)
+        if image_max <= info.max:
+            return image.astype(dtype, copy=False)
+    raise ValueError('Image has values larger than the maximum representable value')
+
+
 def to_8bit(image: np.ndarray, **kwargs) -> np.ndarray:
     """
     Convert an image to 8-bit.
@@ -184,7 +215,9 @@ def adjust_brightness(image: np.ndarray,
 
 def downsample(image: np.ndarray,
                factor: Union[int, Iterable[int]] = 2,
-               keep_input_dtype=True) -> np.ndarray:
+               method: Literal['mean', 'median', 'max', 'min'] = 'mean',
+               keep_input_dtype=True,
+               verbose=False) -> np.ndarray:
     """
     Downsample an image by a given factor along each axis.
 
@@ -213,7 +246,8 @@ def downsample(image: np.ndarray,
         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.')
+        if verbose:
+            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')
@@ -243,8 +277,14 @@ def downsample(image: np.ndarray,
             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)
+    axes_to_collapse = tuple(range(1, len(temp_shape), 2))
+    collapse_functions = {'mean': np.mean, 'max': np.max,
+                          'min': np.min, 'median': np.median}
+    try:
+        collapse_function = collapse_functions[method]
+    except KeyError:
+        raise ValueError(f'method must be one of {collapse_functions.keys()}')
+    image_downsampled = collapse_function(image.reshape(temp_shape), axis=axes_to_collapse)
 
     if keep_input_dtype:
         if np.issubdtype(image.dtype, np.integer):
@@ -533,3 +573,18 @@ def remove_bleedthrough(im, contaminated_slice, source_slice,
     """
     #TODO implement ICA and use it to separate the two independent sources
     raise NotImplementedError
+
+
+def assign_random_colors(data: np.ndarray,
+                         seed: Optional[int] = None,
+                         verbose: bool = False,
+                         ) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    if verbose:
+        print('Finding unique IDs...')
+    unique_ids, inverse = np.unique(data, return_inverse=True)
+    if verbose:
+        print('Assigning random colors...')
+    colors = rng.integers(0, 255, size=(len(unique_ids), 3), dtype=np.uint8)
+    data_colored = colors[inverse].reshape(data.shape + (3,))
+    return data_colored

{numpyimage-2.1.1 → numpyimage-2.2.0}/npimage/utils.py

@@ -75,6 +75,9 @@ def transpose_metadata(metadata: dict or OrderedDict,
     for key, value in metadata.items():
         if isinstance(value, str) or not hasattr(value, '__iter__'):
             continue
+        if key == 'scales':
+            value = [transpose_metadata(scale, inplace=False)
+                     for scale in value]
         if isinstance(value, np.ndarray):
             value = np.flip(value)
         else:
@@ -82,3 +85,65 @@ def transpose_metadata(metadata: dict or OrderedDict,
         metadata[key] = value
     if not inplace:
         return metadata
+
+
+def is_out_of_bounds(coords, shape, allow_negative_wrapping=False, convention='corner'):
+    """
+    Check if coordinates are out of the bounds of a given shape.
+
+    Parameters
+    ----------
+    coords: Coordinates to check (can be a list or numpy array).
+
+    shape: Shape of the volume (tuple or list).
+
+    allow_negative_wrapping
+      If False, all negative coordinates are considered out of bounds
+      If True, negative coordinates with absolute value less than the shape
+      are considered in bounds (in which case they can be used as indices
+      to a list or np.ndarray and they will wrap around).
+
+    convention: 'corner' or 'center' to specify whether the coordinate
+      0 refers to the top-left corner of the first pixel (in which case
+      -0.1 is out of bounds) or the center of the first pixel (in which
+      case -0.1 is in bounds, down to -0.5 being the last in-bounds value).
+
+    Returns
+    -------
+    Boolean array indicating whether each coordinate is within bounds.
+    """
+    if convention not in ['corner', 'center']:
+        raise ValueError("Convention must be 'corner' or 'center'.")
+    if not isinstance(coords, np.ndarray):
+        coords = np.array(coords)
+    if coords.ndim == 1 and coords.shape[0] == len(shape):
+        return is_out_of_bounds(coords[np.newaxis, :], shape,
+                                allow_negative_wrapping, convention)[0]
+    if coords.ndim != 2 or coords.shape[1] != len(shape):
+        raise ValueError(f'Coordinates must be a Nx{len(shape)} array, '
+                         f'but got shape {coords.shape}.')
+
+    upper_limit = shape
+    if allow_negative_wrapping:
+        lower_limit = tuple(-i for i in shape)
+    else:
+        lower_limit = 0
+
+    if convention == 'center':
+        lower_limit = np.array(lower_limit) - 0.5
+        upper_limit = np.array(upper_limit) - 0.5
+
+    underflows = coords < lower_limit
+    overflows = coords >= upper_limit
+
+    return np.logical_or(underflows, overflows).any(axis=-1)
+
+
+def is_in_bounds(*args, **kwargs):
+    return np.logical_not(is_out_of_bounds(*args, **kwargs))
+
+
+def remove_out_of_bounds(coords, shape, allow_negative_wrapping=False,
+                         convention='corner'):
+    in_bounds = is_in_bounds(coords, shape, allow_negative_wrapping, convention)
+    return coords[in_bounds]

{numpyimage-2.1.1 → numpyimage-2.2.0}/numpyimage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 2.1.1
+Version: 2.2.0
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{numpyimage-2.1.1 → numpyimage-2.2.0}/numpyimage.egg-info/SOURCES.txt

@@ -15,4 +15,5 @@ numpyimage.egg-info/PKG-INFO
 numpyimage.egg-info/SOURCES.txt
 numpyimage.egg-info/dependency_links.txt
 numpyimage.egg-info/requires.txt
-numpyimage.egg-info/top_level.txt
+numpyimage.egg-info/top_level.txt
+tests/test_pbm.py

{numpyimage-2.1.1 → numpyimage-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'numpyimage'
-version = '2.1.1'
+version = '2.2.0'
 description = 'Load, save, & manipulate image files as numpy arrays'
 readme.file = 'README.md'
 readme.content-type = 'text/markdown'

numpyimage-2.2.0/tests/test_pbm.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import os
+
+import numpy as np
+
+import npimage
+
+
+def test_pbm_load_save():
+    test_cases = [
+        {
+            "data": np.array([
+                [1, 0, 1, 0, 1],
+                [0, 1, 0, 1, 0],
+                [1, 1, 1, 0, 0]
+            ], dtype=bool),
+            "filename": "test_arbitrary_width.pbm",
+            "description": "PBM read/write, arbitrary width"
+        },
+        {
+            "data": np.array([
+                [1, 0, 1, 0, 1, 0, 1, 0],
+                [0, 1, 0, 1, 0, 1, 0, 1],
+                [1, 1, 1, 1, 0, 0, 0, 0],
+                [0, 0, 0, 0, 1, 1, 1, 1]
+            ], dtype=bool),
+            "filename": "test_multiple_of_8.pbm",
+            "description": "PBM read/write, width a multiple of 8"
+        }
+    ]
+
+    for case in test_cases:
+        test_data = case["data"]
+        test_filename = case["filename"]
+        description = case["description"]
+
+        try:
+            # Save the test data to a PBM file
+            npimage.save(test_data, test_filename)
+
+            # Verify the file size
+            expected_file_size = npimage.filetypes.pbm.predict_file_size(test_data)
+            actual_file_size = os.path.getsize(test_filename)
+            assert actual_file_size == expected_file_size, f"File size mismatch: expected {expected_file_size}, got {actual_file_size}"
+
+            # Load the data back from the PBM file
+            loaded_data = npimage.load(test_filename)
+
+            # Assert that the loaded data matches the original data
+            assert np.array_equal(test_data, loaded_data), f"Loaded data does not match original data for {description}"
+
+            print(f"Test passed: {description} works correctly.")
+        finally:
+            # Clean up the test file
+            if os.path.exists(test_filename):
+                os.remove(test_filename)
+
+
+if __name__ == '__main__':
+    test_pbm_load_save()

numpyimage-2.1.1/npimage/align.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""
-Functions for aligning images.
-"""
-
-import numpy as np
-import cv2 as cv
-
-
-def find_landmark(image: np.ndarray,
-                  landmark: np.ndarray,
-                  search_bbox=None,
-                  metric=cv.TM_CCOEFF_NORMED):
-    """
-    Find the region in an image that most resembles a particular landmark.
-
-    Implementation leverages OpenCV functions, following tutorial at
-    https://docs.opencv.org/4.x/d4/dc6/tutorial_py_template_matching.html
-
-    Parameters
-    ----------
-    image : np.ndarray
-        The image in which to search for the landmark.
-
-    landmark : np.ndarray
-        The landmark to search for in the image.
-
-    search_bbox : list/tuple, optional
-        The bounding box in which to search for the landmark. If you know
-        the landmark you're searching for is in a subset of the image then
-        specifying a search region will save time.
-        If None, the entire image will be searched. If not None, search_bbox
-        should be a list/tuple with two elements. Each element should be either
-        a slice object or a list/tuple of two integers that specify the min and
-        max values of the range.
-        For example, search_bbox=(slice(0, 100), slice(0, 200)) or
-        search_box=([0, 100], [0, 200]) would search the top-left
-        100x200 region of the image.
-
-    metric : cv.TemplateMatchModes, optional
-        The metric to use to compare the landmark to the image. Options are
-        cv.TM_SQDIFF, cv.TM_SQDIFF_NORMED, cv.TM_CCORR, cv.TM_CCORR_NORMED,
-        cv.TM_CCOEFF, cv.TM_CCOEFF_NORMED. Default is cv.TM_CCOEFF_NORMED.
-
-    Returns
-    -------
-    (top_left, match_score) : tuple
-        top_left : tuple
-            The top-left corner of the bounding box in the image that
-            is most similar to the landmark.
-        score : float
-            The score of the match, from 0 to 1. A score of 1 indicates
-            a perfect match.
-    """
-    if search_bbox is not None:
-        if all(isinstance(el, slice) for el in search_bbox):
-            img_to_search = image[search_bbox[0], search_bbox[1]]
-            offset = (search_bbox[0].start, search_bbox[1].start)
-        elif all(isinstance(el, (list, tuple)) and len(el) == 2
-                 for el in search_bbox):
-            img_to_search = image[search_bbox[0][0]:search_bbox[0][1],
-                                  search_bbox[1][0]:search_bbox[1][1]]
-            offset = (search_bbox[0][0], search_bbox[1][0])
-        else:
-            raise ValueError(f"Invalid search_bbox: {search_bbox}. Must "
-                             "be two slices or two (min, max) pairs.")
-    else:
-        img_to_search = image
-        offset = (0, 0)
-
-    # Perform template matching
-    scores = cv.matchTemplate(img_to_search, landmark, metric)
-
-    # TODO implement subpixel max_loc finding.
-    # Perhaps fitting a gaussian peak?
-    min_val, max_val, min_loc, max_loc = cv.minMaxLoc(scores)
-    if metric in [cv.TM_SQDIFF, cv.TM_SQDIFF_NORMED]:
-        top_left = min_loc[::-1]  # Includes a flip from (x, y) to (y, x)
-        match_score = 1 - min_val
-    else:
-        top_left = max_loc[::-1]  # Includes a flip from (x, y) to (y, x)
-        match_score = max_val
-    top_left = (top_left[0] + offset[0], top_left[1] + offset[1])
-    return top_left, match_score