numpyimage 2.3.0__tar.gz → 2.4.1__tar.gz

{numpyimage-2.3.0 → numpyimage-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 2.3.0
+Version: 2.4.1
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -690,6 +690,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pillow
+Requires-Dist: pillow-heif
 Requires-Dist: tifffile
 Requires-Dist: pynrrd
 Requires-Dist: matplotlib

{numpyimage-2.3.0 → numpyimage-2.4.1}/npimage/core.py

@@ -20,9 +20,21 @@ from . import operations, utils
 
 supported_extensions = [
     'tif', 'tiff', 'jpg', 'jpeg', 'png', 'pbm',
-    'nrrd', 'zarr', 'raw', 'vol', 'ng'
+    'nrrd', 'zarr', 'raw', 'vol', 'ng', 'heic'
 ]
 
+# Flag to track if HEIF opener has been registered
+_heif_opener_registered = False
+
+
+def _ensure_heif_opener_registered():
+    """Register the HEIF opener if not already registered."""
+    global _heif_opener_registered
+    if not _heif_opener_registered:
+        from pillow_heif import register_heif_opener
+        register_heif_opener()
+        _heif_opener_registered = True
+
 
 def load(filename, dim_order='zyx', **kwargs):
     """
@@ -54,6 +66,11 @@ def load(filename, dim_order='zyx', **kwargs):
         from PIL import Image
         data = np.array(Image.open(filename)) #PIL.Image.open returns zyx order
 
+    if extension == 'heic':
+        _ensure_heif_opener_registered()
+        from PIL import Image
+        data = np.array(Image.open(filename)) #PIL.Image.open returns zyx order
+
     if extension in ['tif', 'tiff']:
         import tifffile
         data = tifffile.imread(filename) #tifffile.imread returns zyx order
@@ -195,6 +212,11 @@ def save(data,
         from PIL import Image  # pip install pillow
         Image.fromarray(data).save(filename)
 
+    if extension == 'heic':
+        _ensure_heif_opener_registered()
+        from PIL import Image
+        Image.fromarray(data).save(filename)
+
     if extension == 'pbm':
         from .filetypes import pbm
         pbm.save(data, filename, comments=metadata)
@@ -558,3 +580,88 @@ def find_channel_axis(data, expected_channel_axis=[0, -1]):
         if data.shape[axis] in [2, 3, 4]:
             return axis
     return None
+
+
+def load_video(filename, force_rgb=False, progress_bar=True):
+    """
+    Load all images in a video file as a numpy array.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the video file
+    force_rgb : bool, default False
+        If True, always return frames as RGB arrays (shape=(H, W, 3))
+        If False, return frames in their native format (e.g., grayscale if possible)
+    progress_bar : bool, default True
+        If True, display a progress bar
+
+    Returns
+    -------
+    data : numpy.ndarray
+        The video frames as a numpy array, shape (num_frames, height, width[, channels])
+    """
+    try:
+        import av
+    except ImportError:
+        raise ImportError('To use load_video, install PyAV: pip install av')
+    from tqdm import tqdm
+    container = av.open(filename)
+    stream = container.streams.video[0]
+    num_frames = stream.frames
+    if not num_frames or num_frames == 0:
+        # If we don't know the number of frames, we can't preallocate, so
+        # it's hard to do better than the following approach (which temporarily
+        # uses double the amount of RAM than the preallocated approach uses).
+        return np.array(list(lazy_load_video(filename, force_rgb=force_rgb)))
+    else:
+        # Load first image to get shape and dtype
+        frame_iter = container.decode(stream)
+        first_frame = next(frame_iter)
+        if force_rgb:
+            first_img = first_frame.to_ndarray(format='rgb24')
+        else:
+            first_img = first_frame.to_ndarray()
+        # Preallocate memory for the entire array
+        data = np.empty((num_frames, *first_img.shape), dtype=first_img.dtype)
+        # Then fill it up frame by frame
+        data[0] = first_img
+        for i, frame in tqdm(enumerate(frame_iter, start=1), total=num_frames,
+                             desc='Loading video', disable=not progress_bar):
+            if force_rgb:
+                img = frame.to_ndarray(format='rgb24')
+            else:
+                img = frame.to_ndarray()
+            data[i] = img
+        return data
+
+
+def lazy_load_video(filename, force_rgb=False):
+    """
+    Lazily load video frames as numpy arrays using PyAV.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the video file.
+    force_rgb : bool, default False
+        If True, always return frames as RGB arrays (shape=(H, W, 3)).
+        If False, return frames in their native format (e.g., grayscale if possible).
+
+    Yields
+    ------
+    frame : np.ndarray
+        Video frame as a numpy array, shape (height, width[, colors]).
+    """
+    try:
+        import av
+    except ImportError:
+        raise ImportError('To use lazy_load_video, install PyAV: pip install av')
+    container = av.open(filename)
+    stream = container.streams.video[0]
+    for frame in container.decode(stream):
+        if force_rgb:
+            img = frame.to_ndarray(format='rgb24')
+        else:
+            img = frame.to_ndarray()
+        yield img

{numpyimage-2.3.0 → numpyimage-2.4.1}/numpyimage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 2.3.0
+Version: 2.4.1
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -690,6 +690,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pillow
+Requires-Dist: pillow-heif
 Requires-Dist: tifffile
 Requires-Dist: pynrrd
 Requires-Dist: matplotlib

{numpyimage-2.3.0 → numpyimage-2.4.1}/numpyimage.egg-info/SOURCES.txt

@@ -8,12 +8,10 @@ npimage/graphics.py
 npimage/nrrd_utils.py
 npimage/operations.py
 npimage/utils.py
-npimage/filetypes/__init__.py
-npimage/filetypes/pbm.py
 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
-tests/test_pbm.py
-tests/tests.py
+tests/test_heic.py
+tests/test_pbm.py

{numpyimage-2.3.0 → numpyimage-2.4.1}/numpyimage.egg-info/requires.txt

@@ -1,5 +1,6 @@
 numpy
 pillow
+pillow-heif
 tifffile
 pynrrd
 matplotlib

{numpyimage-2.3.0 → numpyimage-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'numpyimage'
-version = '2.3.0'
+version = '2.4.1'
 description = 'Load, save, & manipulate image files as numpy arrays'
 readme.file = 'README.md'
 readme.content-type = 'text/markdown'
@@ -23,6 +23,7 @@ urls = {Repository = 'https://github.com/jasper-tms/npimage'}
 dependencies = [
     'numpy',
     'pillow',
+    'pillow-heif',
     'tifffile',
     'pynrrd',
     'matplotlib',

numpyimage-2.4.1/tests/test_heic.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import os
+import tempfile
+import numpy as np
+import npimage
+
+
+def test_heic_load_save():
+    """Test loading and saving HEIC images."""
+    # Create a simple test image
+    test_data = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Test saving as HEIC
+        heic_filename = os.path.join(tmpdir, "test_image.heic")
+        
+        try:
+            # Save the test data as HEIC
+            npimage.save(test_data, heic_filename)
+            
+            # Verify the file was created
+            assert os.path.exists(heic_filename), "HEIC file was not created"
+            
+            # Load the HEIC file back
+            loaded_data = npimage.load(heic_filename)
+            
+            # Check that the loaded data has the same shape
+            assert loaded_data.shape == test_data.shape, f"Shape mismatch: expected {test_data.shape}, got {loaded_data.shape}"
+            
+            # Check that the data type is correct
+            assert loaded_data.dtype == np.uint8, f"Data type mismatch: expected uint8, got {loaded_data.dtype}"
+            
+            print("Test passed: HEIC load/save functionality works correctly.")
+            
+        except Exception as e:
+            print(f"Test failed with error: {e}")
+            raise
+
+
+def test_heic_extension_support():
+    """Test that HEIC extension is properly recognized."""
+    # Test that HEIC is in the supported extensions
+    assert 'heic' in npimage.core.supported_extensions, "HEIC extension not in supported extensions"
+    
+    # Test that the extension is properly parsed
+    filename = "test_image.heic"
+    extension = filename.split('.')[-1].lower()
+    assert extension == 'heic', f"Extension parsing failed: expected 'heic', got '{extension}'"
+    
+    print("Test passed: HEIC extension is properly supported.")
+
+
+if __name__ == '__main__':
+    try:
+        test_heic_extension_support()
+        test_heic_load_save()
+        print("All HEIC tests passed!")
+    except Exception as e:
+        print(f"HEIC tests failed: {e}")
+        raise

numpyimage-2.3.0/npimage/filetypes/__init__.py

@@ -1 +0,0 @@
-__all__ = ['pbm']

numpyimage-2.3.0/npimage/filetypes/pbm.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""
-Read and write PBM files, whose format is specified at
-http://netpbm.sourceforge.net/doc/pbm.html
-"""
-
-import numpy as np
-
-
-def load(filename):
-    """
-    Load pixel data from a PBM file and return it as a numpy array.
-    The returned array has dimensions ordered y then x, as is
-    standard in Python. This means data.shape is ordered (height, width)
-    """
-    with open(filename, 'rb') as f:
-        assert f.readline() == b'P4\n', 'This is not a PBM file'
-        line = f.readline()
-        while line.startswith(b'#'):  # Print and skip comments
-            print(line.decode().strip('\n'))
-            line = f.readline()
-        line = line.decode().strip().split()
-        w = int(line[0])
-        h = int(line[1])
-
-        # 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):
-    """
-    Write a numpy array to file in PBM format
-    """
-    if not isinstance(data, np.ndarray):
-        raise TypeError('data must be a np.ndarray but was {}'.format(type(data)))
-    if not isinstance(filename, str):
-        raise TypeError('filename must be a str but was {}'.format(type(filename)))
-    if comments is not None and not isinstance(comments, str):
-        raise TypeError('comments must be a str but was {}'.format(type(comments)))
-    with open(filename, 'wb') as f:
-        # Header
-        f.write(b'P4\n')
-
-        # Comments
-        if comments is not None:
-            # Insist on each line starting with a '# '
-            comments = '# ' + comments.replace('\n', '\n# ')
-            # Remove any double '# ', if we created any
-            comments = comments.replace('# # ', '# ')
-            while any([comments.endswith(c) for c in ['#', ' ', '\n']]):
-                comments = comments[:-1]
-            print(comments)
-            f.write(comments.encode())
-            f.write(b'\n')
-
-        # Size
-        f.write(str(data.shape[1]).encode())
-        f.write(b' ')
-        f.write(str(data.shape[0]).encode())
-        f.write(b'\n')
-
-        # Data
-        # 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.3.0/tests/tests.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import fire
-
-import npimage
-import npimage.operations
-
-test_im = np.zeros((8, 8), dtype=np.uint8)
-test_im[0:1, 0:2] = 255
-test_im[1:3, 2:4] = 255
-test_im[3:7, 3:7] = 255
-
-
-def mplshow(*args):
-    npimage.show(*args, mode='matplotlib')
-
-
-def test_offset():
-    mplshow(test_im)
-    mplshow(npimage.operations.offset(test_im, (0.5, 0)))
-    mplshow(npimage.operations.offset(test_im, (0, 0.5)))
-    mplshow(npimage.operations.offset(test_im, (0.5, 0.5)))
-    mplshow(npimage.operations.offset(test_im, (1, 1)))
-
-
-def test_paste():
-    offsets = [('++', [100, 50]),
-               ('+-', [100, -50]),
-               ('-+', [-100, 50]),
-               ('--', [-100, -50])]
-    for offset in offsets:
-        im = npimage.load('firefox-logo.png', dim_order='xy')
-        npimage.operations.paste(im, im, offset[1])
-        npimage.save(im, 'firefox-logo_paste' + offset[0] + '.png', dim_order='xy')
-
-
-if __name__ == '__main__':
-    fire.Fire()