numpyimage 3.6.3__tar.gz → 3.7.1__tar.gz

{numpyimage-3.6.3 → numpyimage-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 3.6.3
+Version: 3.7.1
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License: MIT License
@@ -42,12 +42,28 @@ Requires-Dist: pillow-heif
 Requires-Dist: tifffile
 Requires-Dist: pynrrd
 Requires-Dist: matplotlib
-Requires-Dist: opencv-python-headless
+Provides-Extra: vid
+Requires-Dist: av; extra == "vid"
+Provides-Extra: align
+Requires-Dist: opencv-python-headless; extra == "align"
 Provides-Extra: all
 Requires-Dist: av; extra == "all"
+Requires-Dist: opencv-python-headless; extra == "all"
+Provides-Extra: dev
+Requires-Dist: av; extra == "dev"
+Requires-Dist: opencv-python-headless; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
 Dynamic: license-file
 
 # npimage
+
+[![Tests](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml/badge.svg)](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml)
+[![codecov](https://codecov.io/gh/jasper-tms/npimage/branch/main/graph/badge.svg)](https://codecov.io/gh/jasper-tms/npimage)
+[![PyPI version](https://img.shields.io/pypi/v/numpyimage)](https://pypi.org/project/numpyimage/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/numpyimage)](https://pypi.org/project/numpyimage/)
+[![License](https://img.shields.io/github/license/jasper-tms/npimage)](https://github.com/jasper-tms/npimage/blob/main/LICENSE)
 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 `imageio.py` does that, with `array = npimage.load(filename)`, `npimage.save(array, filename)`, and `npimage.show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. Additionally, `vidio.py` provides `array = npimage.load_video(filename)` and `npimage.save_video(array, filename)` for videos as well. (Another similar library to consider using is [imageio](https://pypi.org/project/imageio/).)
 
 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!)

{numpyimage-3.6.3 → numpyimage-3.7.1}/README.md

@@ -1,4 +1,10 @@
 # npimage
+
+[![Tests](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml/badge.svg)](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml)
+[![codecov](https://codecov.io/gh/jasper-tms/npimage/branch/main/graph/badge.svg)](https://codecov.io/gh/jasper-tms/npimage)
+[![PyPI version](https://img.shields.io/pypi/v/numpyimage)](https://pypi.org/project/numpyimage/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/numpyimage)](https://pypi.org/project/numpyimage/)
+[![License](https://img.shields.io/github/license/jasper-tms/npimage)](https://github.com/jasper-tms/npimage/blob/main/LICENSE)
 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 `imageio.py` does that, with `array = npimage.load(filename)`, `npimage.save(array, filename)`, and `npimage.show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. Additionally, `vidio.py` provides `array = npimage.load_video(filename)` and `npimage.save_video(array, filename)` for videos as well. (Another similar library to consider using is [imageio](https://pypi.org/project/imageio/).)
 
 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!)

{numpyimage-3.6.3 → numpyimage-3.7.1}/npimage/align.py

@@ -2,18 +2,15 @@
 """
 Functions for aligning images.
 """
-from typing import Optional, Tuple, Literal
+from typing import Optional, Tuple
 
 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,
+                  metric: Optional[int] = None,
                   subpixel_accuracy: bool = True
                   ) -> Tuple[Tuple[int, int], float]:
     """
@@ -45,7 +42,8 @@ def find_landmark(image: np.ndarray,
     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.
+        cv.TM_CCOEFF, cv.TM_CCOEFF_NORMED.
+        If left as None, defaults to cv.TM_CCOEFF_NORMED.
 
     Returns
     -------
@@ -57,6 +55,17 @@ def find_landmark(image: np.ndarray,
             The score of the match, from 0 to 1. A score of 1 indicates
             a perfect match.
     """
+    try:
+        import cv2 as cv
+    except ImportError as e:
+        raise ImportError(
+            'find_landmark requires opencv. Install it with '
+            '`pip install numpyimage[align]` or `pip install opencv-python-headless`.'
+        ) from e
+
+    if metric is None:
+        metric = cv.TM_CCOEFF_NORMED
+
     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]]

{numpyimage-3.6.3 → numpyimage-3.7.1}/npimage/imageio.py

@@ -452,6 +452,32 @@ def _ensure_heif_opener_registered() -> None:
     """Register the HEIF opener if not already registered."""
     global _heif_opener_registered
     if not _heif_opener_registered:
+        _check_pyav_not_loaded_before_heif()
         from pillow_heif import register_heif_opener
         register_heif_opener()
         _heif_opener_registered = True
+
+
+def _check_pyav_not_loaded_before_heif() -> None:
+    """Raise a clear error if PyAV has been imported before HEIF.
+
+    On macOS, loading PyAV's bundled native libraries before libheif causes a
+    segfault inside pillow_heif when it first initializes. Loading libheif
+    first (or not loading PyAV at all) avoids the crash. Once libheif is
+    loaded, further HEIF operations and PyAV use coexist fine in the same
+    process.
+    """
+    import sys
+    if sys.platform != 'darwin' or 'av' not in sys.modules:
+        return
+    raise RuntimeError(
+        'Cannot open a HEIC file: PyAV (`av`) has already been imported in '
+        'this process, which on macOS causes pillow_heif to segfault when it '
+        'first loads libheif.\n\n'
+        'Workarounds:\n'
+        '  1. Open/save your HEIC files before any code path that imports '
+        '`av` runs (e.g. before using npimage.VideoStreamer, AVVideoWriter, '
+        'or any other code that uses PyAV).\n'
+        '  2. Do HEIC I/O in a separate Python process from your video I/O.\n'
+        '  3. Use a different image format (PNG, JPEG, TIFF).'
+    )

{numpyimage-3.6.3 → numpyimage-3.7.1}/npimage/vidio.py

@@ -249,7 +249,7 @@ class VideoStreamer:
         self._build_index(cache_index=cache_index)
 
     def _build_index(self, cache_index='auto'):
-        if self.index_filename.exists():
+        if cache_index and self.index_filename.exists():
             return self._load_index()
         if self.verbose:
             print('Building frame timestamp index for fast random frame access...')
@@ -301,9 +301,8 @@ class VideoStreamer:
         if len(frames_pts) == 0:
             raise RuntimeError('No timestamps found in frame metadata')
 
-        self.frames_pts = frames_pts
         self.n_frames = len(frames_pts)
-        self.pts0 = self.frames_pts[0]
+        self.pts0 = frames_pts[0]
         self.rotation = _get_rotation_from_metadata(self.filename)
         index = {}
 
@@ -319,10 +318,14 @@ class VideoStreamer:
             else:
                 index['framerate'] = {'numerator': self._framerate.numerator,
                                       'denominator': self._framerate.denominator}
+            self.frames_pts = range(self.pts0,
+                                    self.pts0 + self.pts_delta * self.n_frames,
+                                    self.pts_delta)
         else:
             # The video is variable framerate
             self._framerate = 'variable'
             index['framerate'] = 'variable'
+            self.frames_pts = frames_pts
 
         index['n_frames'] = self.n_frames
         index['rotation'] = self.rotation
@@ -368,6 +371,9 @@ class VideoStreamer:
                 raise ValueError('pts_delta does not appear to be an integer. This is'
                                  ' unexpected and may indicate a malformed index.')
             self.pts_delta = self.pts_delta.numerator
+            self.frames_pts = range(self.pts0,
+                                    self.pts0 + self.pts_delta * self.n_frames,
+                                    self.pts_delta)
 
     @property
     def framerate(self) -> Union[float, Literal['variable']]:
@@ -394,6 +400,10 @@ class VideoStreamer:
             return 'variable'
         return float(1.0 / self._framerate)
 
+    @property
+    def duration(self) -> float:
+        return float((self.frames_pts[-1] - self.frames_pts[0]) * self.time_base)
+
     def frame_number_to_pts(self, frame_number: int) -> int:
         if hasattr(frame_number, '__iter__'):
             return [self.frame_number_to_pts(n) for n in frame_number]

{numpyimage-3.6.3 → numpyimage-3.7.1}/numpyimage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numpyimage
-Version: 3.6.3
+Version: 3.7.1
 Summary: Load, save, & manipulate image files as numpy arrays
 Author-email: Jasper Phelps <jasper.s.phelps@gmail.com>
 License: MIT License
@@ -42,12 +42,28 @@ Requires-Dist: pillow-heif
 Requires-Dist: tifffile
 Requires-Dist: pynrrd
 Requires-Dist: matplotlib
-Requires-Dist: opencv-python-headless
+Provides-Extra: vid
+Requires-Dist: av; extra == "vid"
+Provides-Extra: align
+Requires-Dist: opencv-python-headless; extra == "align"
 Provides-Extra: all
 Requires-Dist: av; extra == "all"
+Requires-Dist: opencv-python-headless; extra == "all"
+Provides-Extra: dev
+Requires-Dist: av; extra == "dev"
+Requires-Dist: opencv-python-headless; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
 Dynamic: license-file
 
 # npimage
+
+[![Tests](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml/badge.svg)](https://github.com/jasper-tms/npimage/actions/workflows/tests.yml)
+[![codecov](https://codecov.io/gh/jasper-tms/npimage/branch/main/graph/badge.svg)](https://codecov.io/gh/jasper-tms/npimage)
+[![PyPI version](https://img.shields.io/pypi/v/numpyimage)](https://pypi.org/project/numpyimage/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/numpyimage)](https://pypi.org/project/numpyimage/)
+[![License](https://img.shields.io/github/license/jasper-tms/npimage)](https://github.com/jasper-tms/npimage/blob/main/LICENSE)
 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 `imageio.py` does that, with `array = npimage.load(filename)`, `npimage.save(array, filename)`, and `npimage.show(array)` functions that let you easily handle a number of common image file formats without having to remember library-specific syntax. Additionally, `vidio.py` provides `array = npimage.load_video(filename)` and `npimage.save_video(array, filename)` for videos as well. (Another similar library to consider using is [imageio](https://pypi.org/project/imageio/).)
 
 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!)

numpyimage-3.7.1/numpyimage.egg-info/requires.txt

@@ -0,0 +1,24 @@
+numpy
+tqdm
+pillow
+pillow-heif
+tifffile
+pynrrd
+matplotlib
+
+[align]
+opencv-python-headless
+
+[all]
+av
+opencv-python-headless
+
+[dev]
+av
+opencv-python-headless
+pytest
+pytest-cov
+psutil
+
+[vid]
+av

{numpyimage-3.6.3 → numpyimage-3.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'numpyimage'
-version = '3.6.3'
+version = '3.7.1'
 description = 'Load, save, & manipulate image files as numpy arrays'
 readme.file = 'README.md'
 readme.content-type = 'text/markdown'
@@ -28,12 +28,31 @@ dependencies = [
     'tifffile',
     'pynrrd',
     'matplotlib',
-    'opencv-python-headless',
 ]
 
 [project.optional-dependencies]
+vid = [
+    'av',
+]
+align = [
+    'opencv-python-headless',
+]
 all = [
-    'av'
+    'av',
+    'opencv-python-headless',
+]
+dev = [
+    'av',
+    'opencv-python-headless',
+    'pytest',
+    'pytest-cov',
+    'psutil',
+]
+
+[tool.pytest.ini_options]
+testpaths = ['tests']
+markers = [
+    'slow: marks tests that shell out to ffmpeg or write real video files (deselect with -m "not slow")',
 ]
 
 [tool.setuptools.packages.find]

numpyimage-3.7.1/tests/test_heic.py

@@ -0,0 +1,58 @@
+"""Tests for HEIC read/write support."""
+
+import subprocess
+import sys
+import textwrap
+
+import numpy as np
+import pytest
+
+import npimage
+
+
+def test_heic_extension_registered():
+    """HEIC is in the set of supported file extensions."""
+    assert 'heic' in npimage.imageio.supported_extensions
+
+
+def test_heic_load_save_roundtrip(tmp_path):
+    """A uint8 RGB image roundtripped through HEIC keeps its shape and dtype."""
+    data = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
+    path = tmp_path / 'test_image.heic'
+
+    npimage.save(data, str(path))
+    assert path.exists()
+
+    loaded = npimage.load(str(path))
+    assert loaded.shape == data.shape
+    assert loaded.dtype == np.uint8
+
+
+@pytest.mark.skipif(sys.platform != 'darwin', reason='guard only fires on macOS')
+def test_heic_guards_against_pyav_already_imported(tmp_path):
+    """
+    On macOS, importing PyAV before libheif causes a segfault inside
+    pillow_heif. npimage guards against this by raising a RuntimeError with a
+    clear message instead of letting the segfault happen.
+    """
+    script = textwrap.dedent(f"""
+        import av  # noqa: F401
+        import numpy as np
+        import npimage
+        data = np.zeros((10, 10, 3), dtype=np.uint8)
+        try:
+            npimage.save(data, r'{tmp_path / "x.heic"}')
+        except RuntimeError as e:
+            print('GUARD_FIRED:', e)
+            raise SystemExit(0)
+        raise SystemExit('guard did not fire')
+    """)
+    result = subprocess.run(
+        [sys.executable, '-c', script], capture_output=True, text=True
+    )
+    assert result.returncode == 0, (
+        f'subprocess exited {result.returncode}. stdout={result.stdout!r} '
+        f'stderr={result.stderr!r}'
+    )
+    assert 'GUARD_FIRED:' in result.stdout
+    assert 'PyAV' in result.stdout

numpyimage-3.7.1/tests/test_pbm.py

@@ -0,0 +1,37 @@
+"""Tests for PBM read/write roundtripping."""
+
+import numpy as np
+
+import npimage
+
+
+def _roundtrip(data, tmp_path, filename):
+    path = tmp_path / filename
+    npimage.save(data, str(path))
+
+    expected_size = npimage.filetypes.pbm.predict_file_size(data)
+    assert path.stat().st_size == expected_size
+
+    loaded = npimage.load(str(path))
+    assert np.array_equal(data, loaded)
+
+
+def test_pbm_arbitrary_width(tmp_path):
+    """PBM roundtrip with a width that is not a multiple of 8."""
+    data = np.array([
+        [1, 0, 1, 0, 1],
+        [0, 1, 0, 1, 0],
+        [1, 1, 1, 0, 0],
+    ], dtype=bool)
+    _roundtrip(data, tmp_path, 'arbitrary_width.pbm')
+
+
+def test_pbm_width_multiple_of_8(tmp_path):
+    """PBM roundtrip with a width that is a multiple of 8."""
+    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)
+    _roundtrip(data, tmp_path, 'multiple_of_8.pbm')

numpyimage-3.7.1/tests/test_video_streamer.py

@@ -0,0 +1,71 @@
+"""
+Tests for VideoStreamer, particularly handling of HEVC videos with
+negative-PTS priming packets (common in iPhone recordings).
+"""
+
+import subprocess
+
+import numpy as np
+import pytest
+
+import npimage
+
+
+@pytest.mark.slow
+def test_negative_pts_priming_packet(tmp_path):
+    """
+    VideoStreamer correctly handles HEVC videos where the first packet has a
+    negative PTS (a "priming" packet used for B-frame prediction that doesn't
+    produce a decoded frame).
+
+    This is common in iPhone HEVC recordings. The bug was that the index was
+    built from demuxed packets, which included the priming packet's negative
+    PTS. When trying to access frame 0, it would seek to that negative PTS,
+    which no decoded frame ever has, causing a VideoSeekError.
+    """
+    import av
+
+    video_path = tmp_path / 'test_negative_pts.mp4'
+
+    # Create a small HEVC video with a negative-PTS priming packet.
+    # -output_ts_offset shifts timestamps so the first keyframe packet gets a
+    # negative PTS, mimicking iPhone HEVC behavior.
+    result = subprocess.run([
+        'ffmpeg', '-y',
+        '-f', 'lavfi', '-i', 'color=c=red:size=320x240:rate=30:d=1',
+        '-c:v', 'libx265', '-preset', 'ultrafast',
+        '-bf', '2', '-x265-params', 'bframes=2',
+        '-tag:v', 'hvc1',
+        '-output_ts_offset', '-0.033',
+        str(video_path),
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f'ffmpeg failed: {result.stderr}'
+
+    # Verify the test video actually has the problematic structure: more
+    # packets than decoded frames due to the priming packet.
+    with av.open(str(video_path)) as container:
+        stream = container.streams.video[0]
+        pkt_pts = sorted(
+            p.pts for p in container.demux(stream) if p.pts is not None
+        )
+    with av.open(str(video_path)) as container:
+        stream = container.streams.video[0]
+        frame_pts = [f.pts for f in container.decode(stream)]
+
+    assert len(pkt_pts) > len(frame_pts), (
+        f'Test video should have more packets ({len(pkt_pts)}) than decoded '
+        f'frames ({len(frame_pts)}). The test setup may need updating if '
+        f'ffmpeg behavior has changed.'
+    )
+    assert pkt_pts[0] < 0, f'First packet PTS should be negative, got {pkt_pts[0]}'
+
+    vid = npimage.VideoStreamer(str(video_path))
+
+    assert vid.n_frames == len(frame_pts)
+
+    frame = vid[0]
+    assert isinstance(frame, np.ndarray)
+    assert frame.shape == (240, 320, 3)
+
+    last_frame = vid[vid.n_frames - 1]
+    assert isinstance(last_frame, np.ndarray)

numpyimage-3.7.1/tests/test_video_writers.py

@@ -0,0 +1,37 @@
+"""Tests for FFmpegVideoWriter and AVVideoWriter."""
+
+import numpy as np
+import pytest
+
+import npimage
+from npimage.vidio import FFmpegVideoWriter, AVVideoWriter
+
+
+def _animated_frames(base_image, num_frames=30, movement_range=30):
+    """Generate frames that move `base_image` in a small circle."""
+    frames = []
+    for i in range(num_frames):
+        angle = 2 * np.pi * i / num_frames
+        dx = int(movement_range * np.cos(angle))
+        dy = int(movement_range * np.sin(angle))
+        frames.append(npimage.operations.offset(base_image, (dy, dx)))
+    return frames
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize('writer_class', [FFmpegVideoWriter, AVVideoWriter])
+def test_video_writer_roundtrip(writer_class, table_tennis_emoji, tmp_path):
+    """Writing frames with each writer produces a readable, non-empty file."""
+    frames = _animated_frames(table_tennis_emoji, num_frames=30)
+    output = tmp_path / f'{writer_class.__name__}.mp4'
+
+    with writer_class(str(output), framerate=30, overwrite=True) as writer:
+        for frame in frames:
+            writer.write(frame)
+
+    assert output.exists()
+    assert output.stat().st_size > 0
+
+    vid = npimage.VideoStreamer(str(output))
+    assert vid.n_frames == len(frames)
+    assert vid[0].shape[:2] == table_tennis_emoji.shape[:2]

numpyimage-3.6.3/numpyimage.egg-info/requires.txt

@@ -1,11 +0,0 @@
-numpy
-tqdm
-pillow
-pillow-heif
-tifffile
-pynrrd
-matplotlib
-opencv-python-headless
-
-[all]
-av

numpyimage-3.6.3/tests/test_heic.py

@@ -1,61 +0,0 @@
-#!/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-3.6.3/tests/test_pbm.py

@@ -1,61 +0,0 @@
-#!/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-3.6.3/tests/test_video_streamer.py

@@ -1,92 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for VideoStreamer, particularly handling of HEVC videos with
-negative-PTS priming packets (common in iPhone recordings).
-"""
-
-import os
-import subprocess
-import tempfile
-
-import numpy as np
-
-import npimage
-
-
-def test_negative_pts_priming_packet():
-    """
-    Test that VideoStreamer correctly handles HEVC videos where the first
-    packet has a negative PTS (a "priming" packet used for B-frame prediction
-    that doesn't produce a decoded frame).
-
-    This is common in iPhone HEVC recordings. The bug was that the index was
-    built from demuxed packets, which included the priming packet's negative
-    PTS. When trying to access frame 0, it would seek to that negative PTS,
-    which no decoded frame ever has, causing a VideoSeekError.
-    """
-    with tempfile.TemporaryDirectory() as tmpdir:
-        video_path = os.path.join(tmpdir, 'test_negative_pts.mp4')
-
-        # Create a small HEVC video with a negative-PTS priming packet.
-        # The -output_ts_offset shifts timestamps so the first keyframe packet
-        # gets a negative PTS, mimicking iPhone HEVC behavior.
-        result = subprocess.run([
-            'ffmpeg', '-y',
-            '-f', 'lavfi', '-i', 'color=c=red:size=320x240:rate=30:d=1',
-            '-c:v', 'libx265', '-preset', 'ultrafast',
-            '-bf', '2', '-x265-params', 'bframes=2',
-            '-tag:v', 'hvc1',
-            '-output_ts_offset', '-0.033',
-            video_path
-        ], capture_output=True, text=True)
-        assert result.returncode == 0, f'ffmpeg failed: {result.stderr}'
-
-        # Verify the test video actually has the problematic structure:
-        # more packets than decoded frames due to the priming packet
-        import av
-        with av.open(video_path) as container:
-            stream = container.streams.video[0]
-            pkt_pts = sorted(
-                p.pts for p in container.demux(stream) if p.pts is not None
-            )
-        with av.open(video_path) as container:
-            stream = container.streams.video[0]
-            frame_pts = [f.pts for f in container.decode(stream)]
-
-        assert len(pkt_pts) > len(frame_pts), (
-            f'Test video should have more packets ({len(pkt_pts)}) than '
-            f'decoded frames ({len(frame_pts)}). The test setup may need '
-            f'updating if ffmpeg behavior has changed.'
-        )
-        assert pkt_pts[0] < 0, (
-            f'First packet PTS should be negative, got {pkt_pts[0]}'
-        )
-
-        # Now test that VideoStreamer handles this correctly
-        vid = npimage.VideoStreamer(video_path)
-
-        # The number of frames should match decoded frames, not packets
-        assert vid.n_frames == len(frame_pts), (
-            f'Expected {len(frame_pts)} frames, got {vid.n_frames}'
-        )
-
-        # Accessing frame 0 should work without raising VideoSeekError
-        frame = vid[0]
-        assert isinstance(frame, np.ndarray)
-        assert frame.shape == (240, 320, 3)
-
-        # Accessing the last frame should also work
-        last_frame = vid[vid.n_frames - 1]
-        assert isinstance(last_frame, np.ndarray)
-
-        print(f'PASSED: Loaded {vid.n_frames} frames from video with '
-              f'negative-PTS priming packet')
-
-
-def main():
-    test_negative_pts_priming_packet()
-    print('\nAll VideoStreamer tests passed.')
-
-
-if __name__ == '__main__':
-    main()

numpyimage-3.6.3/tests/test_video_writers.py

@@ -1,170 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to compare FFmpegVideoWriter and AVVideoWriter implementations.
-Uses the table tennis emoji image with animated movement to create test videos.
-"""
-
-import os
-import time
-import tempfile
-import psutil
-import gc
-from pathlib import Path
-
-import numpy as np
-
-import npimage
-from npimage.vidio import FFmpegVideoWriter, AVVideoWriter
-
-script_dir = Path(__file__).parent
-
-# Memory monitoring
-process = psutil.Process(os.getpid())
-
-
-def print_memory(label):
-    """Print current memory usage"""
-    gc.collect()
-    mem = process.memory_info().rss / 1024 / 1024
-    print(f"{label}: {mem:.1f} MB")
-
-
-def create_animated_frames(base_image, num_frames=60, movement_range=128):
-    """Create animated frames by moving the image around"""
-    frames = []
-    height, width = base_image.shape[:2]
-
-    for i in range(num_frames):
-        # Create circular motion
-        angle = 2 * np.pi * i / num_frames
-        dx = int(movement_range * np.cos(angle))
-        dy = int(movement_range * np.sin(angle))
-
-        # Apply offset to create movement
-        frame = npimage.operations.offset(base_image, (dy, dx))
-        frames.append(frame)
-
-    return frames
-
-
-def test_video_writer(writer_class, filename, frames, writer_name):
-    """Test a specific video writer class"""
-    print(f"\n=== Testing {writer_name} ===")
-    print_memory(f"Before {writer_name}")
-
-    start_time = time.time()
-
-    try:
-        with writer_class(filename, framerate=30, overwrite=True) as writer:
-            for i, frame in enumerate(frames):
-                if i % 20 == 0:  # Print progress every 20 frames
-                    print(f"  Writing frame {i}/{len(frames)}")
-                writer.write(frame)
-
-        elapsed = time.time() - start_time
-        file_size = os.path.getsize(filename) / 1024  # KB
-
-        print_memory(f"After {writer_name}")
-        print(f"✓ {writer_name} completed:")
-        print(f"  Time: {elapsed:.2f} seconds")
-        print(f"  File size: {file_size:.1f} KB")
-        print(f"  Frames per second: {len(frames)/elapsed:.1f}")
-
-        return True
-
-    except Exception as e:
-        print(f"✗ {writer_name} failed: {e}")
-        return False
-
-
-def test_memory_leak(writer_class, frames, writer_name, num_iterations=5):
-    """Test for memory leaks by creating multiple videos"""
-    print(f"\n=== Memory Leak Test for {writer_name} ===")
-    print_memory("Initial memory")
-
-    for i in range(num_iterations):
-        filename = script_dir / "videos" / f"memory_test_{writer_name.lower()}_{i+1}.mp4"
-        
-        print_memory(f"Before iteration {i+1}")
-
-        with writer_class(filename, framerate=30, overwrite=True) as writer:
-            for frame in frames:
-                writer.write(frame)
-
-        print_memory(f"After iteration {i+1}")
-
-    print_memory(f"Final memory after {num_iterations} iterations")
-
-
-def main():
-    print("Video Writer Comparison Test")
-    print("=" * 60)
-    
-    # Check FFmpeg version
-    print("\nChecking FFmpeg version...")
-    import subprocess
-    try:
-        result = subprocess.run(['ffmpeg', '-version'], capture_output=True, text=True)
-        ffmpeg_version = result.stdout.split('\n')[0]
-        print(f"FFmpeg version: {ffmpeg_version}")
-    except Exception as e:
-        print(f"Error checking FFmpeg version: {e}")
-
-    # Load the table tennis emoji image
-    print("\nLoading table tennis emoji image...")
-    image_path = script_dir / "table-tennis-emoji.png"
-    if not os.path.exists(image_path):
-        print(f"Error: Image not found at {image_path}")
-        return
-
-    base_image = npimage.load(image_path)
-    print(f"Loaded image: {base_image.shape}, dtype: {base_image.dtype}")
-
-    # Create animated frames
-    print("\nCreating animated frames...")
-    frames = create_animated_frames(base_image, num_frames=60, movement_range=30)
-    print(f"Created {len(frames)} animated frames")
-
-    # Test both video writers
-    results = {}
-    
-    # Test FFmpegVideoWriter
-    ffmpeg_filename = script_dir / "videos" / "table_tennis_ffmpeg.mp4"
-    results['FFmpegVideoWriter'] = test_video_writer(
-        FFmpegVideoWriter, ffmpeg_filename, frames, "FFmpegVideoWriter"
-    )
-    
-    # Test AVVideoWriter
-    av_filename = script_dir / "videos" / "table_tennis_av.mp4"
-    results['AVVideoWriter'] = test_video_writer(
-        AVVideoWriter, av_filename, frames, "AVVideoWriter"
-    )
-
-    # Memory leak tests
-    print("\n" + "=" * 60)
-    print("MEMORY LEAK TESTS")
-    print("=" * 60)
-
-    # Use a smaller set of frames for memory leak testing
-    test_frames = frames[:30]  # 30 frames for faster testing
-
-    if results.get('FFmpegVideoWriter', False):
-        test_memory_leak(FFmpegVideoWriter, test_frames, "FFmpegVideoWriter")
-
-    if results.get('AVVideoWriter', False):
-        test_memory_leak(AVVideoWriter, test_frames, "AVVideoWriter")
-
-    # Summary
-    print("\n" + "=" * 60)
-    print("SUMMARY")
-    print("=" * 60)
-
-    for writer_name, success in results.items():
-        status = "✓ PASSED" if success else "✗ FAILED"
-        print(f"{writer_name}: {status}")
-
-    print("\n🎉 Test completed!")
-
-
-if __name__ == "__main__":
-    main()