ojph 0.0.1__tar.gz

ojph-0.0.1/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright 2024, Ramona Optics Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ojph-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: ojph
+Version: 0.0.1
+Summary: OpenJPH Bindings for Python and Numpy
+Home-page: https://github.com/ramonaoptics/ojph
+Author: Mark Harfouche
+Author-email: mark@ramonaoptics.com
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24.0
+
+OpenJPH bindings

ojph-0.0.1/README.md

@@ -0,0 +1 @@
+OpenJPH bindings

ojph-0.0.1/ojph/__init__.py

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

ojph-0.0.1/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-0.0.1/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()

ojph-0.0.1/ojph/_static_version.py

@@ -0,0 +1,2 @@
+# This file has been created by setup.py.
+version = '0.0.1'

ojph-0.0.1/ojph/_version.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+# This file is part of 'miniver': https://github.com/jbweston/miniver
+#
+from collections import namedtuple
+import os
+import subprocess
+
+Version = namedtuple("Version", ("release", "dev", "labels"))
+
+# No public API
+__all__ = []
+
+package_root = os.path.dirname(os.path.realpath(__file__))
+package_name = os.path.basename(package_root)
+
+STATIC_VERSION_FILE = "_static_version.py"
+
+
+def get_version(version_file=STATIC_VERSION_FILE):
+    version_info = get_static_version_info(version_file)
+    version = version_info["version"]
+    if version == "__use_git__":
+        version = get_version_from_git()
+        if not version:
+            version = get_version_from_git_archive(version_info)
+        if not version:
+            version = Version("unknown", None, None)
+        return pep440_format(version)
+    else:
+        return version
+
+
+def get_static_version_info(version_file=STATIC_VERSION_FILE):
+    version_info = {}
+    with open(os.path.join(package_root, version_file), "rb") as f:
+        exec(f.read(), {}, version_info)
+    return version_info
+
+
+def version_is_from_git(version_file=STATIC_VERSION_FILE):
+    return get_static_version_info(version_file)["version"] == "__use_git__"
+
+
+def pep440_format(version_info):
+    release, dev, labels = version_info
+
+    version_parts = [release]
+    if dev:
+        if release.endswith("-dev") or release.endswith(".dev"):
+            version_parts.append(dev)
+        else:  # prefer PEP440 over strict adhesion to semver
+            version_parts.append(".post{}".format(dev))
+
+    if labels:
+        version_parts.append("+")
+        version_parts.append(".".join(labels))
+
+    return "".join(version_parts)
+
+
+def get_version_from_git():
+    # git describe --first-parent does not take into account tags from branches
+    # that were merged-in. The '--long' flag gets us the 'dev' version and
+    # git hash, '--always' returns the git hash even if there are no tags.
+    for opts in [["--first-parent"], []]:
+        try:
+            p = subprocess.Popen(
+                ["git", "describe", "--tags", "--long", "--always"] + opts,
+                cwd=package_root,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except OSError:
+            return
+        if p.wait() == 0:
+            break
+    else:
+        return
+
+    if os.environ.get("OJPH_GIT_DESCRIBE", None):
+        git_describe = os.environ["OJPH_GIT_DESCRIBE"]
+    else:
+        git_describe = p.communicate()[0].decode()
+
+    description = (
+        git_describe
+        .strip("v")  # Tags can have a leading 'v', but the version should not
+        .rstrip("\n")
+        .rsplit("-", 2)  # Split the latest tag, commits since tag, and hash
+    )
+
+    try:
+        release, dev, git = description
+    except ValueError:  # No tags, only the git hash
+        # prepend 'g' to match with format returned by 'git describe'
+        git = "g{}".format(*description)
+        release = "unknown"
+        dev = None
+
+    labels = []
+    if dev == "0":
+        dev = None
+    else:
+        labels.append(git)
+
+    try:
+        p = subprocess.Popen(["git", "diff", "--quiet"], cwd=package_root)
+    except OSError:
+        labels.append("confused")  # This should never happen.
+    else:
+        if p.wait() == 1:
+            labels.append("dirty")
+
+    return Version(release, dev, labels)
+
+
+# TODO: change this logic when there is a git pretty-format
+#       that gives the same output as 'git describe'.
+#       Currently we can only tell the tag the current commit is
+#       pointing to, or its hash (with no version info)
+#       if it is not tagged.
+def get_version_from_git_archive(version_info):
+    try:
+        refnames = version_info["refnames"]
+        git_hash = version_info["git_hash"]
+    except KeyError:
+        # These fields are not present if we are running from an sdist.
+        # Execution should never reach here, though
+        return None
+
+    if git_hash.startswith("$Format") or refnames.startswith("$Format"):
+        # variables not expanded during 'git archive'
+        return None
+
+    VTAG = "tag: v"
+    refs = set(r.strip() for r in refnames.split(","))
+    version_tags = set(r[len(VTAG) :] for r in refs if r.startswith(VTAG))
+    if version_tags:
+        release, *_ = sorted(version_tags)  # prefer e.g. "2.0" over "2.0rc1"
+        return Version(release, dev=None, labels=None)
+    else:
+        return Version("unknown", dev=None, labels=["g{}".format(git_hash)])
+
+
+__version__ = get_version()
+
+
+# The following section defines a 'get_cmdclass' function
+# that can be used from setup.py. The '__version__' module
+# global is used (but not modified).
+
+
+def _write_version(fname):
+    # This could be a hard link, so try to delete it first.  Is there any way
+    # to do this atomically together with opening?
+    try:
+        os.remove(fname)
+    except OSError:
+        pass
+    with open(fname, "w") as f:
+        f.write(
+            "# This file has been created by setup.py.\n"
+            "version = '{}'\n".format(__version__)
+        )
+
+
+def get_cmdclass(pkg_source_path):
+    from setuptools.command.build_py import build_py as build_py_orig
+    from setuptools.command.sdist import sdist as sdist_orig
+
+    class _build_py(build_py_orig):
+        def run(self):
+            super().run()
+
+            src_marker = "".join(["src", os.path.sep])
+
+            if pkg_source_path.startswith(src_marker):
+                path = pkg_source_path[len(src_marker):]
+            else:
+                path = pkg_source_path
+            _write_version(
+                os.path.join(
+                    self.build_lib, path, STATIC_VERSION_FILE
+                )
+            )
+
+    class _sdist(sdist_orig):
+        def make_release_tree(self, base_dir, files):
+            super().make_release_tree(base_dir, files)
+            _write_version(
+                os.path.join(base_dir, pkg_source_path, STATIC_VERSION_FILE)
+            )
+
+    return dict(sdist=_sdist, build_py=_build_py)

ojph-0.0.1/ojph/ojph_bindings.cpp

@@ -0,0 +1,183 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+
+#include <openjph/ojph_file.h>
+#include <openjph/ojph_codestream.h>
+#include <openjph/ojph_mem.h>
+#include <openjph/ojph_params.h>
+
+namespace py = pybind11;
+using namespace ojph;
+
+PYBIND11_MODULE(ojph_bindings, m) {
+    py::class_<infile_base>(m, "InfileBase")
+        .def("read", &infile_base::read)
+        .def("seek", &infile_base::seek)
+        .def("tell", &infile_base::tell)
+        .def("eof", &infile_base::eof)
+        .def("close", &infile_base::close);
+
+    py::class_<j2c_infile, infile_base>(m, "J2CInfile")
+        .def(py::init<>())
+        .def("open", &j2c_infile::open)
+        .def("read", &j2c_infile::read)
+        .def("seek", [](infile_base& self, si64 offset, int origin) {
+            return self.seek(offset, static_cast<enum infile_base::seek>(origin));
+        })
+        .def("tell", &j2c_infile::tell)
+        .def("eof", &j2c_infile::eof)
+        .def("close", &j2c_infile::close);
+
+    py::class_<mem_infile, infile_base>(m, "MemInfile")
+        .def(py::init<>())
+        .def("open", &mem_infile::open)
+        .def("read", &mem_infile::read)
+        .def("seek", [](mem_infile& self, si64 offset, int origin) {
+            return self.seek(offset, static_cast<enum infile_base::seek>(origin));
+        })
+        .def("tell", &mem_infile::tell)
+        .def("eof", &mem_infile::eof)
+        .def("close", &mem_infile::close);
+
+
+    py::class_<outfile_base>(m, "outfileBase")
+        .def("write", &outfile_base::write)
+        .def("seek", &outfile_base::seek)
+        .def("tell", &outfile_base::tell)
+        .def("close", &outfile_base::close);
+
+    py::class_<j2c_outfile, outfile_base>(m, "J2COutfile")
+        .def(py::init<>())
+        .def("open", &j2c_outfile::open)
+        .def("write", &j2c_outfile::write)
+        .def("tell", &j2c_outfile::tell)
+        .def("close", &j2c_outfile::close);
+
+    // Bindings for codestream class
+    py::class_<codestream>(m, "Codestream")
+        .def(py::init<>())
+        .def("set_planar", &codestream::set_planar)
+        .def("set_profile", &codestream::set_profile)
+        .def("set_tilepart_divisions", &codestream::set_tilepart_divisions)
+        .def("is_tilepart_division_at_resolutions", &codestream::is_tilepart_division_at_resolutions)
+        .def("is_tilepart_division_at_components", &codestream::is_tilepart_division_at_components)
+        .def("request_tlm_marker", &codestream::request_tlm_marker)
+        .def("is_tlm_requested", &codestream::is_tlm_requested)
+        .def("write_headers",
+             [](codestream &self, outfile_base *file, py::object comments, ui32 num_comments) {
+                 // Check if the comments argument is None and convert it to nullptr if so
+                 const comment_exchange* comments_ptr = comments.is_none() ? nullptr : comments.cast<const comment_exchange*>();
+                 self.write_headers(file, comments_ptr, num_comments);
+             },
+             py::arg("file"), py::arg("comments") = py::none(), py::arg("num_comments") = 0)
+        .def("exchange",
+             [](codestream &self, py::object line_buf_obj, ui32 &next_component) -> line_buf* {
+                 line_buf* buf = nullptr;
+                 if (!line_buf_obj.is_none()) {
+                     buf = line_buf_obj.cast<line_buf*>();
+                 }
+                 return self.exchange(buf, next_component);
+             },
+             py::arg("line_buf_obj") = py::none(), py::arg("next_component") = 0)
+        .def("flush", &codestream::flush)
+        .def("enable_resilience", &codestream::enable_resilience)
+        .def("read_headers", &codestream::read_headers)
+        .def("restrict_input_resolution", &codestream::restrict_input_resolution)
+        .def("create", &codestream::create)
+        .def("pull", &codestream::pull)
+        .def("close", &codestream::close)
+        .def("access_siz", &codestream::access_siz)
+        .def("access_cod", &codestream::access_cod)
+        .def("access_qcd", &codestream::access_qcd)
+        .def("access_nlt", &codestream::access_nlt)
+        .def("is_planar", &codestream::is_planar);
+
+    py::class_<point>(m, "Point")
+        .def(py::init<ui32, ui32>(), py::arg("x") = 0, py::arg("y") = 0)  // Constructor with default args
+        .def_readwrite("x", &point::x)
+        .def_readwrite("y", &point::y);
+
+    py::class_<size>(m, "Size")
+        .def(py::init<ui32, ui32>(), py::arg("w") = 0, py::arg("h") = 0)  // Constructor with default args
+        .def_readwrite("w", &size::w)  // width
+        .def_readwrite("h", &size::h)  // height
+        .def("area", &size::area);     // Expose the area function
+
+    py::class_<param_siz>(m, "ParamSiz")
+        // .def(py::init<local::param_siz*>())  // Constructor with local::param_siz* argument
+        .def("is_signed", &param_siz::is_signed)
+
+        .def("set_image_extent", &param_siz::set_image_extent)
+        .def("set_tile_size", &param_siz::set_tile_size)
+        .def("set_image_offset", &param_siz::set_image_offset)
+        .def("set_tile_offset", &param_siz::set_tile_offset)
+        .def("set_num_components", &param_siz::set_num_components)
+        .def("set_component", &param_siz::set_component, py::arg("comp_num"), py::arg("downsampling"), py::arg("bit_depth"), py::arg("is_signed"))
+
+        .def("get_image_extent", &param_siz::get_image_extent)
+        .def("get_image_offset", &param_siz::get_image_offset)
+        .def("get_tile_size", &param_siz::get_tile_size)
+        .def("get_tile_offset", &param_siz::get_tile_offset)
+        .def("get_num_components", &param_siz::get_num_components)
+        .def("get_bit_depth", &param_siz::get_bit_depth)
+        .def("get_downsampling", &param_siz::get_downsampling)
+        .def("get_recon_width", &param_siz::get_recon_width)
+        .def("get_recon_height", &param_siz::get_recon_height);
+
+    py::class_<param_cod>(m, "ParamCod")
+        // .def(py::init<local::param_cod*>())
+
+        .def("set_num_decomposition", &param_cod::set_num_decomposition, py::arg("num_decompositions"))
+        .def("set_block_dims", &param_cod::set_block_dims, py::arg("width"), py::arg("height"))
+        .def("set_precinct_size", &param_cod::set_precinct_size, py::arg("num_levels"), py::arg("precinct_size"))
+        .def("set_progression_order", &param_cod::set_progression_order, py::arg("name"))
+        .def("set_color_transform", &param_cod::set_color_transform, py::arg("color_transform"))
+        .def("set_reversible", &param_cod::set_reversible, py::arg("reversible"))
+
+        .def("get_num_decompositions", &param_cod::get_num_decompositions)
+        .def("get_block_dims", &param_cod::get_block_dims)
+        .def("get_log_block_dims", &param_cod::get_log_block_dims)
+        .def("is_reversible", &param_cod::is_reversible)
+        .def("get_precinct_size", &param_cod::get_precinct_size, py::arg("level_num"))
+        .def("get_log_precinct_size", &param_cod::get_log_precinct_size, py::arg("level_num"))
+        .def("get_progression_order", &param_cod::get_progression_order)
+        .def("get_progression_order_as_string", &param_cod::get_progression_order_as_string)
+        .def("get_num_layers", &param_cod::get_num_layers)
+        .def("is_using_color_transform", &param_cod::is_using_color_transform)
+        .def("packets_may_use_sop", &param_cod::packets_may_use_sop)
+        .def("packets_use_eph", &param_cod::packets_use_eph)
+        .def("get_block_vertical_causality", &param_cod::get_block_vertical_causality);
+
+    py::class_<line_buf, std::unique_ptr<line_buf, py::nodelete>>(m, "LineBuf")
+        .def(py::init<>())
+
+        .def_readwrite("size", &line_buf::size)
+        .def_readwrite("pre_size", &line_buf::pre_size)
+
+        // Wrapping i32 and f32 members as properties (since they are in a union)
+        // .def_property("i32", [](line_buf &self) { return self.i32; }, [](line_buf &self, si32* ptr) { self.i32 = ptr; })
+        // .def_property("f32", [](line_buf &self) { return self.f32; }, [](line_buf &self, float* ptr) { self.f32 = ptr; })
+        // Wrapping i32 and f32 members as addresses (pointers)
+        .def_property("i32_address",
+            [](line_buf &self) { return reinterpret_cast<uintptr_t>(self.i32); },  // Cast to uintptr_t to pass as integer
+            [](line_buf &self, uintptr_t ptr) { self.i32 = reinterpret_cast<si32*>(ptr); }
+        )  // Assign pointer back to i32
+        .def_property("f32_address",
+            [](line_buf &self) { return reinterpret_cast<uintptr_t>(self.f32); },  // Same for float pointer
+            [](line_buf &self, uintptr_t ptr) { self.f32 = reinterpret_cast<float*>(ptr); }
+        )
+
+        // Explicit instantiations for pre_alloc, finalize_alloc, and wrap for int and float
+        // .def("pre_alloc_int", &line_buf::pre_alloc<int>, py::arg("allocator"), py::arg("num_ele"), py::arg("pre_size"))
+        // .def("pre_alloc_float", &line_buf::pre_alloc<float>, py::arg("allocator"), py::arg("num_ele"), py::arg("pre_size"))
+
+        // .def("finalize_alloc_int", &line_buf::finalize_alloc<int>, py::arg("allocator"))
+        // .def("finalize_alloc_float", &line_buf::finalize_alloc<float>, py::arg("allocator"))
+
+        // .def("wrap_int", &line_buf::wrap<int>, py::arg("buffer"), py::arg("num_ele"), py::arg("pre_size"))
+        // .def("wrap_float", &line_buf::wrap<float>, py::arg("buffer"), py::arg("num_ele"), py::arg("pre_size"))
+    ;
+
+}
+

ojph-0.0.1/ojph.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: ojph
+Version: 0.0.1
+Summary: OpenJPH Bindings for Python and Numpy
+Home-page: https://github.com/ramonaoptics/ojph
+Author: Mark Harfouche
+Author-email: mark@ramonaoptics.com
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24.0
+
+OpenJPH bindings

ojph-0.0.1/ojph.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.py
+ojph/__init__.py
+ojph/_imread.py
+ojph/_imwrite.py
+ojph/_static_version.py
+ojph/_version.py
+ojph/ojph_bindings.cpp
+ojph.egg-info/PKG-INFO
+ojph.egg-info/SOURCES.txt
+ojph.egg-info/dependency_links.txt
+ojph.egg-info/not-zip-safe
+ojph.egg-info/requires.txt
+ojph.egg-info/top_level.txt
+tests/test_lossless_compression.py
+tests/test_package.py

ojph-0.0.1/ojph.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ojph-0.0.1/ojph.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

ojph-0.0.1/ojph.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.24.0

ojph-0.0.1/ojph.egg-info/top_level.txt

@@ -0,0 +1 @@
+ojph

ojph-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "pybind11"]
+build-backend = "setuptools.build_meta"

ojph-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ojph-0.0.1/setup.py

@@ -0,0 +1,84 @@
+import platform
+import sys
+import os
+from setuptools import setup, find_packages, Extension
+# Hmm consider nanobind
+import pybind11
+
+with open('README.md', 'r', encoding='utf-8') as fh:
+    readme = fh.read()
+
+def get_version_and_cmdclass(pkg_path):
+    """Load version.py module without importing the whole package.
+
+    Template code from miniver
+    """
+    import os
+    from importlib.util import module_from_spec, spec_from_file_location
+
+    spec = spec_from_file_location("version", os.path.join(pkg_path, "_version.py"))
+    module = module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.__version__, module.get_cmdclass(pkg_path)
+
+
+version, cmdclass = get_version_and_cmdclass("ojph")
+
+# Include the pybind11 include directory
+include_dirs = [pybind11.get_include()]
+library_dirs = []
+
+# Check for windows, add PREFIX/Library to the include dirs for compatibility with conda-forge
+# This doesn't really hurt...
+if platform.system() == 'Windows':
+    prefix = sys.prefix
+    # For conda environments
+    include_dirs.append(os.path.join(prefix, 'Library', 'include'))
+    library_dirs.append(os.path.join(prefix, 'Library', 'lib'))
+
+# Define the extension module
+ojph_module = Extension(
+    'ojph.ojph_bindings',
+    sources=['ojph/ojph_bindings.cpp'],
+    include_dirs=include_dirs,
+    library_dirs=library_dirs,
+    libraries=['openjph'],
+    extra_compile_args=[]
+)
+
+# Setup
+setup(
+    name='ojph',
+    version=version,
+    cmdclass=cmdclass,
+    description='OpenJPH Bindings for Python and Numpy',
+    long_description=readme,
+    url='https://github.com/ramonaoptics/ojph',
+    author='Mark Harfouche',
+    author_email='mark@ramonaoptics.com',
+    license='BSD-3-Clause',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 3 :: Only',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    packages=find_packages(exclude=["tests*"]),
+    python_requires='>=3.10',
+    install_requires=[
+        'numpy>=1.24.0',
+    ],
+    license_files=('LICENSE.txt',),
+    ext_modules=[ojph_module],
+    include_package_data=True,
+    zip_safe=False
+)
+

ojph-0.0.1/tests/test_lossless_compression.py

@@ -0,0 +1,25 @@
+from ojph import imwrite, imread
+import numpy as np
+import pytest
+
+
+@pytest.mark.parametrize(
+    'shape', [
+        (200, 100),
+        (1024, 256),
+        (256, 1024),
+        (1024, 1024),
+        (1024, 2048),
+        (4096, 2048),
+        (4096, 4096),
+        (8192, 1024),
+        (8192, 8192),
+    ]
+)
+def test_write_lossless(shape, tmp_path):
+    filename = tmp_path / 'test.jp2'
+    data = np.random.randint(0, 256, shape, dtype=np.uint8)
+    imwrite(filename, data)
+    image_read = imread(filename)
+
+    np.testing.assert_array_equal(data, image_read)

ojph-0.0.1/tests/test_package.py

@@ -0,0 +1,16 @@
+import ojph
+
+
+def test_init():
+    ojph.__version__
+
+
+def test_imports():
+    from ojph import imread
+    from ojph import imwrite
+    from ojph._imread import OJPHImageFile
+
+    # Ensure that this stuff "works"
+    imread
+    imwrite
+    OJPHImageFile