seaotter 0.0.1__tar.gz

seaotter-0.0.1/LICENSE

@@ -0,0 +1 @@
+Contact Dan Jacobellis

seaotter-0.0.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seaotter
+Version: 0.0.1
+Summary: Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval 
+Author-email: Dan Jacobellis <danjacobellis@utexas.edu>
+License-Expression: LicenseRef-Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Dynamic: license-file
+
+# seaotter
+Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval 

seaotter-0.0.1/README.md

@@ -0,0 +1,2 @@
+# seaotter
+Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval 

seaotter-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seaotter"
+version = "0.0.1"
+description = "Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval "
+authors = [
+    {name = "Dan Jacobellis", email = "danjacobellis@utexas.edu"}
+]
+readme = "README.md"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "torch",
+]
+requires-python = ">=3.6"

seaotter-0.0.1/setup.cfg

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

seaotter-0.0.1/src/seaotter/__init__.py

@@ -0,0 +1,3 @@
+from .transcode import encode, transcode
+
+__all__ = ["encode", "transcode"]

seaotter-0.0.1/src/seaotter/transcode.py

@@ -0,0 +1,117 @@
+"""One-time transcode between the SEA OTTER compressed latent format and
+standard image formats.
+
+Sensor side (embedded, low power): run the lightweight encoder, quantize to
+int8, and save each latent channel as a separate lossless JPEG-LS file.
+
+Cloud side (GPU available): load the per-channel JPEG-LS files, regroup them
+into the model's multi-scale latent structure, and run the heavy DNN decoder
+once to produce a reconstruction that can then be re-saved in any standard
+image format (PNG, JPEG, AVIF, ...).
+
+The `encode` and `transcode` functions here are deliberately decoupled from a
+specific autoencoder class. They rely only on the duck-typed interface:
+    model.encode(x) -> list[Tensor(B, C_group, H_s, W_s)]
+    model.decode(latents) -> Tensor(B, C, H, W)
+    model.scale_groups   -> list[tuple[ps, start, end]]
+"""
+
+import io
+
+import PIL.Image
+import pillow_jpls  # noqa: F401  registers the JPEG-LS codec with Pillow
+import torch
+from torchvision.transforms.v2.functional import pil_to_tensor, to_pil_image
+
+
+def _channel_to_jpegls(plane_int8: torch.Tensor) -> bytes:
+    """Encode a single int8 latent plane (H, W) as a JPEG-LS byte string.
+
+    int8 values in [-127, 127] are shifted by +127 into uint8 [0, 254] for
+    JPEG-LS, which stores unsigned samples.
+    """
+    assert plane_int8.dim() == 2, f"expected 2D plane, got {tuple(plane_int8.shape)}"
+    uint8 = (plane_int8.to(torch.long) + 127).to(torch.uint8).cpu()
+    buff = io.BytesIO()
+    to_pil_image(uint8).save(buff, format="JPEG-LS")
+    return buff.getvalue()
+
+
+def _jpegls_to_channel(data: bytes) -> torch.Tensor:
+    """Decode a JPEG-LS byte string back to an int8 (H, W) latent plane."""
+    img = PIL.Image.open(io.BytesIO(data))
+    uint8 = pil_to_tensor(img)  # (1, H, W) uint8
+    return (uint8[0].to(torch.long) - 127).to(torch.int8)
+
+
+def encode(model, x):
+    """Encode an image through the codec to per-channel JPEG-LS bytes.
+
+    Args:
+        model: an autoencoder exposing ``encode(x) -> list[Tensor]`` where each
+            latent has shape (B, C_group, H_s, W_s). ``scale_groups`` is used
+            by :func:`transcode` on the receiver side and must match.
+        x: (1, C, H, W) input tensor in the model's input domain (typically
+            linear RGB in [-1, 1] for this codec), placed on the same device
+            as the model.
+
+    Returns:
+        list[bytes]: one JPEG-LS file per latent channel, ordered by scale
+        group (coarsest first), then by channel index within each group.
+    """
+    if x.shape[0] != 1:
+        raise ValueError(f"encode expects batch size 1, got {x.shape[0]}")
+
+    with torch.inference_mode():
+        latents = model.encode(x)
+        latents_q = [z.round().clamp(-127, 127).to(torch.int8) for z in latents]
+
+    files = []
+    for z in latents_q:
+        for c in range(z.shape[1]):
+            files.append(_channel_to_jpegls(z[0, c]))
+    return files
+
+
+def transcode(model, channel_files, device=None):
+    """Decode per-channel JPEG-LS bytes through the DNN decoder.
+
+    This is the one-time transcode step: run it once in the cloud after data
+    leaves the sensor to obtain a reconstruction in a standard image format.
+    Subsequent retrieval (human viewing, ML training) can then read the
+    standard output without touching the large decoder again.
+
+    Args:
+        model: the autoencoder whose scale structure matches ``encode``. Must
+            expose ``decode(latents)`` and ``scale_groups`` (list of
+            ``(ps, start, end)`` tuples).
+        channel_files: list of bytes as produced by :func:`encode`, ordered by
+            scale group (coarsest first), then by channel within each group.
+        device: target device for the latents. Defaults to the model's device.
+
+    Returns:
+        Tensor of shape (1, C, H, W) in [-1, 1] — the decoded image. Convert
+        to [0, 1] and re-save as PNG/JPEG/... for downstream use.
+    """
+    if device is None:
+        device = next(model.parameters()).device
+
+    expected = sum(end - start for _, start, end in model.scale_groups)
+    if len(channel_files) != expected:
+        raise ValueError(
+            f"expected {expected} channel files for model.scale_groups="
+            f"{list(model.scale_groups)}, got {len(channel_files)}"
+        )
+
+    latents = []
+    idx = 0
+    for _ps, start, end in model.scale_groups:
+        n_ch = end - start
+        planes = [_jpegls_to_channel(channel_files[idx + c]) for c in range(n_ch)]
+        idx += n_ch
+        z = torch.stack(planes, dim=0).unsqueeze(0).to(device)  # (1, C_group, H, W)
+        latents.append(z)
+
+    with torch.inference_mode():
+        xhat = model.decode(latents).clamp(-1, 1)
+    return xhat

seaotter-0.0.1/src/seaotter.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seaotter
+Version: 0.0.1
+Summary: Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval 
+Author-email: Dan Jacobellis <danjacobellis@utexas.edu>
+License-Expression: LicenseRef-Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Dynamic: license-file
+
+# seaotter
+Sensor-Embedded Asymmetric codec with One-Time Transcode for Efficient Retrieval 

seaotter-0.0.1/src/seaotter.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/seaotter/__init__.py
+src/seaotter/transcode.py
+src/seaotter.egg-info/PKG-INFO
+src/seaotter.egg-info/SOURCES.txt
+src/seaotter.egg-info/dependency_links.txt
+src/seaotter.egg-info/requires.txt
+src/seaotter.egg-info/top_level.txt

seaotter-0.0.1/src/seaotter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seaotter-0.0.1/src/seaotter.egg-info/requires.txt

@@ -0,0 +1 @@
+torch

seaotter-0.0.1/src/seaotter.egg-info/top_level.txt

@@ -0,0 +1 @@
+seaotter