Merge pull request #2 from ramonaoptics/fix_workflows

Fix workflows and add basic tests.

Author: hmaarrfk

.github/workflows/pypi.yaml

@@ -30,7 +30,10 @@ jobs:
         run: python -m pip install --upgrade pip build
 
       - name: Build Distributions
-        run: python -m build --sdist --wheel --outdir dist/
+        # While I would love to build a wheel, I just don't know how
+        # with a c-dependency
+        # run: python -m build --sdist --wheel --outdir dist/
+        run: python -m build --sdist --outdir dist/
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/tests.yml

@@ -8,13 +8,19 @@ on:
 
 jobs:
   build:
-    name: Tests on Python ${{ matrix.python-version }}
+    name: Tests on (${{ matrix.python-version }}, ${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false
       matrix:
         os: ["ubuntu-latest", "macos-latest", "windows-latest"]
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10"]
+        include:
+          - os: "ubuntu-latest"
+            installer-url: "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh"
+          - os: "macos-latest"
+            installer-url: "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-x86_64.sh"
+          - os: "windows-latest"
+            installer-url: "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Windows-x86_64.exe"
       max-parallel: 8
       fail-fast: false
 
@@ -33,28 +39,35 @@ jobs:
       - uses: conda-incubator/setup-miniconda@v3
         with:
           auto-update-conda: true
+          installer-url: ${{ matrix.installer-url }}
           python-version: ${{ matrix.python-version }}
       - name: Conda info
         shell: bash -el {0}
-        run: conda info
+        run: |
+          conda config --remove channels defaults
+          conda config --add channels mark.harfouche
+          conda info
       - name: Conda list
         shell: pwsh
         run: |
           conda list
-          conda config --add channels mark.harfouche
 
       - name: Install dependencies
+        shell: bash -el {0}
         run: |
-          mamba install numpy openjph setuptools pytest --yes
+          conda install compilers pybind11 numpy openjph setuptools pytest --yes
 
       - name: Install package
+        shell: bash -el {0}
         run: |
           export OJPH_GIT_DESCRIBE=${{ steps.ghd.outputs.describe }}
-          python -m pip install . -vvv
+          python -m pip install -e . -vvv
 
       - name: Run tests
+        shell: bash -el {0}
         run: |
           export OJPH_GIT_DESCRIBE=${{ steps.ghd.outputs.describe }}
           python --version
           pip check
           python -c "import ojph; print(ojph.__version__)"
+          pytest

ojph/__init__.py

@@ -1 +1,6 @@
 from ._version import __version__
+
+from ._imwrite import imwrite
+from ._imread import imread
+
+__all__ = ["imwrite", "imread"]

ojph/_imread.py

@@ -0,0 +1,102 @@
+import os
+import numpy as np
+import ctypes
+from .ojph_bindings import J2CInfile, Codestream
+from warnings import warn
+
+# Copy the imageio.v3.imread signature
+def imread(uri, *, index=None, plugin=None, extension=None, format_hint=None, **kwargs):
+    if index is not None:
+        warn(f"index {index} is ignored", stacklevel=2)
+    if plugin is not None:
+        warn(f"plugin {plugin} is ignored", stacklevel=2)
+    if extension is not None:
+        warn(f"extension {extension} is ignored", stacklevel=2)
+    if format_hint is not None:
+        warn(f"format_hint {format_hint} is ignored", stacklevel=2)
+
+    return OJPHImageFile(uri).read_image()
+
+
+class OJPHImageFile:
+    def __init__(self, filename):
+        self._codestream = None
+        self._ojph_file = None
+        self._filename = filename
+
+        self._ojph_file = J2CInfile()
+        self._ojph_file.open(str(filename))
+        self._codestream = Codestream()
+        self._codestream.read_headers(self._ojph_file)
+
+
+        siz = self._codestream.access_siz()
+        extents = siz.get_image_extent()
+        self._shape = extents.y, extents.x
+        self._is_planar = self._codestream.is_planar()
+
+        bit_depth = siz.get_bit_depth(0)
+        is_signed = siz.is_signed(0)
+        if bit_depth == 8 and not is_signed:
+            self._dtype = np.uint8
+        elif bit_depth == 8 and is_signed:
+            self._dtype = np.int8
+        elif bit_depth == 16 and not is_signed:
+            self._dtype = np.uint16
+        elif bit_depth == 16 and is_signed:
+            self._dtype = np.int16
+        elif bit_depth == 32 and not is_signed:
+            self._dtype = np.uint32
+        elif bit_depth == 32 and is_signed:
+            self._dtype = np.int32
+        else:
+            raise ValueError("Unsupported bit depth")
+
+    def _open_file(self):
+        self._ojph_file = J2CInfile()
+        self._ojph_file.open(self._filename)
+        self._codestream = Codestream()
+        self._codestream.read_headers(self._ojph_file)
+
+    def read_image(self, *, level=0):
+        if self._codestream is None:
+            self._open_file()
+
+        self._codestream.restrict_input_resolution(level, level)
+        siz = self._codestream.access_siz()
+
+        height = siz.get_recon_height(0)
+        width = siz.get_recon_width(0)
+        self._codestream.create()
+
+        image = np.zeros(
+            (height, width),
+            dtype=self._dtype
+        )
+
+        for h in range(height):
+            line = self._codestream.pull(0)
+            # Convert the address to a ctypes pointer to int32
+            i32_ptr = ctypes.cast(line.i32_address, ctypes.POINTER(ctypes.c_uint32))
+
+            # Calculate the total number of bytes (size of the array in elements * size of int32)
+            line_array = np.ctypeslib.as_array(
+                ctypes.cast(i32_ptr, ctypes.POINTER(ctypes.c_uint32)),
+                shape=(line.size,)
+            )
+            image[h] = line_array
+
+        self._close_codestream_and_file()
+        return image
+
+    def _close_codestream_and_file(self):
+        if self._codestream is not None:
+            self._codestream.close()
+            # The codestream will close the infile automatically
+        elif self._ojph_file is not None:
+            self._ojph_file.close()
+        self._codestream = None
+        self._ojph_file = None
+
+    def __del__(self):
+        self._close_codestream_and_file()

ojph/_imwrite.py

@@ -0,0 +1,82 @@
+import numpy as np
+import ctypes
+
+from .ojph_bindings import Codestream, J2COutfile, Point
+
+
+def imwrite(filename, image):
+    # In the future we might be able to pass in a channel_order parameter
+    if image.ndim == 2:
+        channel_order = 'HW'
+    else:
+        channel_order = 'HWC'
+
+    channel_order = channel_order.upper()
+
+    if len(channel_order) != image.ndim:
+        raise ValueError(
+            f"The channel order ({channel_order}) must be consistent "
+            f"with the image dimensions ({image.ndim})."
+        )
+
+    ojph_file = J2COutfile()
+    ojph_file.open(str(filename))
+    codestream = Codestream()
+
+    siz = codestream.access_siz()
+    width = image.shape[channel_order.index('W')]
+    height = image.shape[channel_order.index('H')]
+
+    # What does planar mean? it doesn't seem to mean components...
+    # is_planar = 'C' in channel_order
+    siz.set_image_extent(Point(width, height))
+    if 'C' in channel_order:
+        num_components = channel_order.index('C')
+    else:
+        num_components = 1
+
+    bit_depth = image.dtype.itemsize * 8
+    # Is there a better way to detect signed dtypes???
+    is_signed = image.dtype.kind != 'u'
+    siz.set_num_components(num_components);
+    for i in range(num_components):
+        # is it necessary to do this in a loop?
+        siz.set_component(
+            i,
+            Point(1, 1), # component downsampling
+            bit_depth,
+            is_signed,
+        )
+    cod = codestream.access_cod()
+    # cod.set_progression_oder
+    # code.set_color_Transform
+    cod.set_reversible(True)
+    # codestream.set_profile()
+
+    # set tile_size
+    # set tile offset
+    # planar true is likely for things like
+    # YUV420 where the Y, U, and V planes are stored
+    # sparately
+    codestream.set_planar(False)
+
+    codestream.write_headers(ojph_file, None, 0)
+    c = 0
+    line = codestream.exchange(None, c)
+    for i in range(height):
+        for c in range(num_components):
+            i32_ptr = ctypes.cast(line.i32_address, ctypes.POINTER(ctypes.c_uint32))
+            # Calculate the total number of bytes (size of the array in elements * size of int32)
+            line_array = np.ctypeslib.as_array(
+                ctypes.cast(i32_ptr, ctypes.POINTER(ctypes.c_uint32)),
+                shape=(line.size,)
+            )
+            if image.ndim == 2:
+                line_array[...] = image[i, :]
+            else:
+                line_array[...] = image[i, :, c]
+            c_before = c
+            line = codestream.exchange(line, c)
+
+    codestream.flush()
+    codestream.close()