serron 0.0.1__tar.gz

serron-0.0.1/CMakeLists.txt

@@ -0,0 +1,97 @@
+cmake_minimum_required(VERSION 3.24)
+
+if(NOT DEFINED CMAKE_CUDA_COMPILER)
+    if(DEFINED ENV{CUDA_HOME})
+        set(CMAKE_CUDA_COMPILER "$ENV{CUDA_HOME}/bin/nvcc" CACHE FILEPATH "" FORCE)
+    else()
+        find_program(_NVCC nvcc)
+        if(_NVCC)
+            set(CMAKE_CUDA_COMPILER "${_NVCC}" CACHE FILEPATH "" FORCE)
+        endif()
+    endif()
+endif()
+
+
+project(morphottention LANGUAGES CXX CUDA)
+
+#  23 host / 20 device
+set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CUDA_STANDARD 20)
+set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_CUDA_SEPARABLE_COMPILATION OFF)
+
+set(CMAKE_CUDA_ARCHITECTURES 90 100 120)
+set(TORCH_CUDA_ARCH_LIST "9.0;10.0;12.0")
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(Python_FIND_VIRTUALENV FIRST)
+
+find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
+
+execute_process(
+        COMMAND ${Python_EXECUTABLE} -c "import torch; print(torch.utils.cmake_prefix_path)"
+        OUTPUT_VARIABLE TORCH_CMAKE_PREFIX
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+list(APPEND CMAKE_PREFIX_PATH "${TORCH_CMAKE_PREFIX}")
+find_package(Torch REQUIRED CONFIG)
+
+
+execute_process(
+        COMMAND ${Python_EXECUTABLE} -c "import pathlib, torch; print(pathlib.Path(torch.__file__).resolve().parent / 'lib')"
+        OUTPUT_VARIABLE TORCH_LIB_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+if(NOT EXISTS "${TORCH_LIB_DIR}")
+    message(FATAL_ERROR "Could not locate torch lib dir at: ${TORCH_LIB_DIR}")
+endif()
+
+find_package(CUDAToolkit REQUIRED)
+
+Python_add_library(_C MODULE WITH_SOABI
+        csrc/bindings.cpp
+        csrc/cuda/morphology.cu
+)
+
+# -lineinfo on Debug; full device debug (-G) only when explicitly sanitizing.
+option(CUDA_SANITIZE "Build device code with -G for compute-sanitizer" OFF)
+target_compile_options(_C PRIVATE
+        $<$<COMPILE_LANG_AND_ID:CUDA,NVIDIA>:--threads=0>
+        $<$<AND:$<COMPILE_LANG_AND_ID:CUDA,NVIDIA>,$<CONFIG:Debug>>:-lineinfo>
+        $<$<AND:$<COMPILE_LANG_AND_ID:CUDA,NVIDIA>,$<CONFIG:Debug>,$<BOOL:${CUDA_SANITIZE}>>:-G>
+)
+
+
+if(MSVC)
+    target_compile_options(_C PRIVATE
+            $<$<COMPILE_LANGUAGE:CXX>:/Zc:preprocessor>
+            $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=/Zc:preprocessor>
+    )
+endif()
+
+target_include_directories(_C PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/csrc
+        ${CMAKE_CURRENT_SOURCE_DIR}/csrc/compat
+        ${TORCH_INCLUDE_DIRS}
+        ${Python_INCLUDE_DIRS}
+        ${CUDAToolkit_INCLUDE_DIRS}
+)
+
+target_link_libraries(_C PRIVATE
+        ${TORCH_LIBRARIES}
+        CUDA::cudart
+        CUDA::cublas
+)
+
+if(NOT WIN32)
+    set_target_properties(_C PROPERTIES
+            BUILD_RPATH   "${TORCH_LIB_DIR}"
+            INSTALL_RPATH "$ORIGIN/../torch/lib"
+    )
+endif()
+
+install(TARGETS _C LIBRARY DESTINATION serron)

serron-0.0.1/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.2
+Name: serron
+Version: 0.0.1
+Summary:  Mathematical Morphology module for PyTorch (CUDA), providing differentiable operators and learnable network layers.
+Keywords: cuda,pytorch,morphology
+Author-Email: Vedran Hrabar <vedran.hrabar@outlook.com>
+License: MIT
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: GPU
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Environment :: GPU :: NVIDIA CUDA :: 13
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: repository, https://github.com/vhrabar/serron
+Project-URL: documentation, https://github.com/vhrabar/serron/wiki
+Project-URL: Bug Tracker, https://github.com/vhrabar/serron/issues
+Requires-Python: >=3.12
+Requires-Dist: torch>=2.12
+Description-Content-Type: text/markdown
+
+# Serron
+
+Mathematical Morphology module for PyTorch (CUDA), providing differentiable operators and learnable network layers.
+## Install
+
+Prebuilt wheels are published for CPython 3.14 on Linux (x86_64, aarch64) and
+Windows (x86_64). A working CUDA-enabled PyTorch (`torch >= 2.12`) must already
+be installed in the environment.
+
+```bash
+pip install serron
+```
+
+## Usage
+
+> **Alpha:** the CUDA kernels are not wired up yet, so the operators below currently
+> raise `NotImplementedError`. 
+
+Serron works on standard PyTorch tensors laid out as `(N, C, H, W)` and living on a CUDA
+device.
+
+### Functional operators
+
+Stateless operators live in `serron.functional` and are re-exported at the top level.
+Each takes an input tensor, a structuring element, and an optional `border` mode:
+
+```python
+import torch
+import serron
+from serron import BorderMode
+from serron import structuring_element as se
+
+x = torch.rand(1, 1, 256, 256, device="cuda")
+kernel = se.disk(3, device="cuda")
+
+eroded  = serron.erosion(x, kernel)
+dilated = serron.dilatation(x, kernel)
+opened  = serron.opening(x, kernel)
+closed  = serron.closing(x, kernel)
+
+# Derived operators
+grad    = serron.gradient(x, kernel)   # dilate(x) - erode(x)
+white   = serron.top_hat(x, kernel)    # x - open(x)
+black   = serron.black_hat(x, kernel)  # close(x) - x
+
+# Control border handling
+eroded_reflect = serron.erosion(x, kernel, border=BorderMode.REFLECT)
+```
+
+Available operators: `erosion`, `dilatation`, `opening`, `closing`, `gradient`,
+`top_hat`, `black_hat`.
+
+### Structuring elements
+
+`serron.structuring_element` builds common SE shapes on the requested device:
+
+```python
+from serron import structuring_element as se
+
+se.square(5, device="cuda")      # (5, 5) full square
+se.cross(5, device="cuda")       # (5, 5) plus shape
+se.disk(3, device="cuda")        # (7, 7) disk, radius 3
+se.diamond(3, device="cuda")     # (7, 7) diamond, radius 3
+se.from_tensor(my_weights)       # wrap an arbitrary 2-D tensor as a grayscale SE
+```
+
+### Border modes
+
+`BorderMode` controls how out-of-bounds neighbors are handled:
+
+| Mode | Behavior |
+| --- | --- |
+| `BorderMode.REPLICATE` | Repeat the edge value (default) |
+| `BorderMode.REFLECT` | Mirror across the edge |
+| `BorderMode.CONSTANT` | Pad with a constant |
+
+### Learnable layers
+
+`serron` also exposes `torch.nn.Module` layers with a learnable structuring element,
+so morphology can be trained end-to-end inside a network. Each layer takes the number
+of `channels` and a `kernel_size`:
+
+```python
+import torch
+from serron import Erosion2d, Dilation2d, Opening2d, Closing2d
+from serron import BorderMode
+
+layer = Erosion2d(channels=3, kernel_size=5, border=BorderMode.REPLICATE).cuda()
+
+x = torch.rand(8, 3, 64, 64, device="cuda")
+y = layer(x)          # forward pass; layer.weight is a trainable (C, k, k) SE
+y.sum().backward()    # gradients flow into layer.weight
+```
+
+Available layers: `Erosion2d`, `Dilation2d`, `Opening2d`, `Closing2d`.
+
+## Building from source
+
+Requires the CUDA 13.X toolkit (`nvcc`) and a matching `torch` build:
+
+```bash
+uv sync --package serron --no-dev --group build
+uv build --package serron --wheel --no-build-isolation
+```
+
+## License
+
+MIT
+
+Copyright © 2026 Vedran Hrabar.

serron-0.0.1/README.md

@@ -0,0 +1,110 @@
+# Serron
+
+Mathematical Morphology module for PyTorch (CUDA), providing differentiable operators and learnable network layers.
+## Install
+
+Prebuilt wheels are published for CPython 3.14 on Linux (x86_64, aarch64) and
+Windows (x86_64). A working CUDA-enabled PyTorch (`torch >= 2.12`) must already
+be installed in the environment.
+
+```bash
+pip install serron
+```
+
+## Usage
+
+> **Alpha:** the CUDA kernels are not wired up yet, so the operators below currently
+> raise `NotImplementedError`. 
+
+Serron works on standard PyTorch tensors laid out as `(N, C, H, W)` and living on a CUDA
+device.
+
+### Functional operators
+
+Stateless operators live in `serron.functional` and are re-exported at the top level.
+Each takes an input tensor, a structuring element, and an optional `border` mode:
+
+```python
+import torch
+import serron
+from serron import BorderMode
+from serron import structuring_element as se
+
+x = torch.rand(1, 1, 256, 256, device="cuda")
+kernel = se.disk(3, device="cuda")
+
+eroded  = serron.erosion(x, kernel)
+dilated = serron.dilatation(x, kernel)
+opened  = serron.opening(x, kernel)
+closed  = serron.closing(x, kernel)
+
+# Derived operators
+grad    = serron.gradient(x, kernel)   # dilate(x) - erode(x)
+white   = serron.top_hat(x, kernel)    # x - open(x)
+black   = serron.black_hat(x, kernel)  # close(x) - x
+
+# Control border handling
+eroded_reflect = serron.erosion(x, kernel, border=BorderMode.REFLECT)
+```
+
+Available operators: `erosion`, `dilatation`, `opening`, `closing`, `gradient`,
+`top_hat`, `black_hat`.
+
+### Structuring elements
+
+`serron.structuring_element` builds common SE shapes on the requested device:
+
+```python
+from serron import structuring_element as se
+
+se.square(5, device="cuda")      # (5, 5) full square
+se.cross(5, device="cuda")       # (5, 5) plus shape
+se.disk(3, device="cuda")        # (7, 7) disk, radius 3
+se.diamond(3, device="cuda")     # (7, 7) diamond, radius 3
+se.from_tensor(my_weights)       # wrap an arbitrary 2-D tensor as a grayscale SE
+```
+
+### Border modes
+
+`BorderMode` controls how out-of-bounds neighbors are handled:
+
+| Mode | Behavior |
+| --- | --- |
+| `BorderMode.REPLICATE` | Repeat the edge value (default) |
+| `BorderMode.REFLECT` | Mirror across the edge |
+| `BorderMode.CONSTANT` | Pad with a constant |
+
+### Learnable layers
+
+`serron` also exposes `torch.nn.Module` layers with a learnable structuring element,
+so morphology can be trained end-to-end inside a network. Each layer takes the number
+of `channels` and a `kernel_size`:
+
+```python
+import torch
+from serron import Erosion2d, Dilation2d, Opening2d, Closing2d
+from serron import BorderMode
+
+layer = Erosion2d(channels=3, kernel_size=5, border=BorderMode.REPLICATE).cuda()
+
+x = torch.rand(8, 3, 64, 64, device="cuda")
+y = layer(x)          # forward pass; layer.weight is a trainable (C, k, k) SE
+y.sum().backward()    # gradients flow into layer.weight
+```
+
+Available layers: `Erosion2d`, `Dilation2d`, `Opening2d`, `Closing2d`.
+
+## Building from source
+
+Requires the CUDA 13.X toolkit (`nvcc`) and a matching `torch` build:
+
+```bash
+uv sync --package serron --no-dev --group build
+uv build --package serron --wheel --no-build-isolation
+```
+
+## License
+
+MIT
+
+Copyright © 2026 Vedran Hrabar.

serron-0.0.1/csrc/bindings.cpp

@@ -0,0 +1,18 @@
+#include "ops.h"
+#include "registration.h"
+
+#include <torch/library.h>
+
+// Operator schemas, registered under the serron:: namespace.
+TORCH_LIBRARY_EXPAND(TORCH_EXTENSION_NAME, ops) {
+    ops.def("erode(Tensor input, Tensor kernel, int border) -> Tensor");
+    ops.def("dilate(Tensor input, Tensor kernel, int border) -> Tensor");
+}
+
+// CUDA implementations.
+TORCH_LIBRARY_IMPL_EXPAND(TORCH_EXTENSION_NAME, CUDA, ops) {
+    ops.impl("erode", &serron::erode);
+    ops.impl("dilate", &serron::dilate);
+}
+
+REGISTER_EXTENSION(TORCH_EXTENSION_NAME)

serron-0.0.1/csrc/compat/registration.h

@@ -0,0 +1,16 @@
+#ifndef SERRON_COMPAT_REGISTRATION_H
+#define SERRON_COMPAT_REGISTRATION_H
+
+// Compatibility shim for the local CMake / PyPI build.
+
+#include <torch/library.h>
+
+#define TORCH_LIBRARY_EXPAND(NAME, MODULE) TORCH_LIBRARY(NAME, MODULE)
+
+#define TORCH_LIBRARY_IMPL_EXPAND(NAME, DEVICE, MODULE) TORCH_LIBRARY_IMPL(NAME, DEVICE, MODULE)
+
+#define TORCH_EXTENSION_NAME serron
+
+#define REGISTER_EXTENSION(NAME)
+
+#endif // SERRON_COMPAT_REGISTRATION_H

serron-0.0.1/csrc/cuda/morphology.cu

@@ -0,0 +1,17 @@
+#include "ops.h"
+
+#include <c10/util/Exception.h>
+
+
+namespace serron {
+
+at::Tensor erode(const at::Tensor& input, const at::Tensor& kernel, int64_t border) {
+    TORCH_CHECK_NOT_IMPLEMENTED(false, "serron::erode is not implemented yet");
+}
+
+at::Tensor dilate(const at::Tensor& input, const at::Tensor& kernel, int64_t border) {
+
+    TORCH_CHECK_NOT_IMPLEMENTED(false, "serron::dilate is not implemented yet");
+}
+
+} // namespace serron

serron-0.0.1/csrc/ops.h

@@ -0,0 +1,13 @@
+#ifndef SERRON_OPS_H
+#define SERRON_OPS_H
+
+#include <torch/torch.h>
+
+namespace serron {
+
+at::Tensor erode(const at::Tensor& input, const at::Tensor& kernel, int64_t border);
+at::Tensor dilate(const at::Tensor& input, const at::Tensor& kernel, int64_t border);
+
+} // namespace serron
+
+#endif // SERRON_OPS_H

serron-0.0.1/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "serron"
+version = "0.0.1"
+description = " Mathematical Morphology module for PyTorch (CUDA), providing differentiable operators and learnable network layers."
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Vedran Hrabar", email = "vedran.hrabar@outlook.com" },
+]
+license = { text = "MIT" }
+keywords = ["cuda", "pytorch", "morphology",]
+
+classifiers = [
+    "Development Status :: 1 - Planning",
+
+    "Environment :: GPU",
+    "Environment :: GPU :: NVIDIA CUDA",
+    "Environment :: GPU :: NVIDIA CUDA :: 13",
+
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+
+    "License :: OSI Approved :: MIT License",
+
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+
+    "Programming Language :: C++",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Implementation :: CPython",
+
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "torch>=2.12",
+]
+
+[project.urls]
+repository = "https://github.com/vhrabar/serron"
+documentation =  "https://github.com/vhrabar/serron/wiki"
+"Bug Tracker" = "https://github.com/vhrabar/serron/issues"
+
+
+[[tool.uv.index]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cu132"
+explicit = true
+
+[tool.uv.sources]
+torch = { index = "pytorch" }
+torchvision = { index = "pytorch" }
+
+
+[build-system]
+requires = ["scikit-build-core==1.0.2"]
+build-backend = "scikit_build_core.build"
+
+
+[dependency-groups]
+build = ["scikit-build-core==1.0.2", "cmake", "ninja"]
+
+
+
+[tool.scikit-build]
+minimum-version = "build-system.requires"
+cmake.version = ">=3.24"
+build-dir = "build/{wheel_tag}"
+
+wheel.packages = ["torch-ext/serron"]
+editable.rebuild = true

serron-0.0.1/torch-ext/serron/__init__.py

@@ -0,0 +1,36 @@
+"""
+Serron: CUDA-accelerated mathematical morphology for PyTorch.
+"""
+
+from __future__ import annotations
+
+from . import functional, structuring_element
+from .enums import BorderMode, Operation
+from .functional import (
+    black_hat,
+    closing,
+    dilatation,
+    erosion,
+    gradient,
+    opening,
+    top_hat,
+)
+from .modules import Closing2d, Dilation2d, Erosion2d, Opening2d
+
+__all__ = [
+    "BorderMode",
+    "Closing2d",
+    "Dilation2d",
+    "Erosion2d",
+    "Opening2d",
+    "Operation",
+    "black_hat",
+    "closing",
+    "dilatation",
+    "erosion",
+    "functional",
+    "gradient",
+    "opening",
+    "structuring_element",
+    "top_hat",
+]

serron-0.0.1/torch-ext/serron/_cmake_ops.py

@@ -0,0 +1,33 @@
+"""
+Op-namespace loader for the local CMake / PyPI build.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+
+import torch
+
+_NAMESPACE = "serron"
+
+
+def _load_c_extension() -> None:
+    pkg_dir = os.path.dirname(__file__)
+    for pattern in ("_C*.so", "_C*.pyd", "_C*.dll"):
+        matches = glob.glob(os.path.join(pkg_dir, pattern))
+        if matches:
+            torch.ops.load_library(matches[0])  # type: ignore[no-untyped-call]
+            return
+    raise ImportError(
+        f"Could not find the compiled Serron '_C' extension in {pkg_dir}. Reinstall the package so the CUDA kernels are built."
+    )
+
+
+_load_c_extension()
+
+ops = getattr(torch.ops, _NAMESPACE)
+
+
+def add_op_namespace_prefix(op_name: str) -> str:
+    return f"{_NAMESPACE}::{op_name}"

serron-0.0.1/torch-ext/serron/autograd.py

@@ -0,0 +1,12 @@
+"""
+Autograd wrapper and nn.Module around the compiled serron CUDA kernels.
+"""
+
+from __future__ import annotations
+
+import contextlib
+
+with contextlib.suppress(ImportError):
+    from ._ops import add_op_namespace_prefix, ops  # type: ignore[import-not-found]
+
+__all__ = ["add_op_namespace_prefix", "ops"]

serron-0.0.1/torch-ext/serron/enums.py

@@ -0,0 +1,31 @@
+"""
+Enumerations shared across the morphology ops and layers.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Operation(Enum):
+    """
+    Morphological operations
+    """
+
+    ERODE = "erode"
+    DILATE = "dilate"
+    OPEN = "open"
+    CLOSE = "close"
+    GRADIENT = "gradient"
+    TOP_HAT = "top_hat"
+    BLACK_HAT = "black_hat"
+
+
+class BorderMode(Enum):
+    """
+    OuB neighborhood border mode.
+    """
+
+    REFLECT = "reflect"
+    REPLICATE = "replicate"
+    CONSTANT = "constant"

serron-0.0.1/torch-ext/serron/functional.py

@@ -0,0 +1,86 @@
+"""
+Stateless morphological operations backed by the CUDA kernels.
+"""
+
+from __future__ import annotations
+
+import torch
+
+from .enums import BorderMode
+
+
+def erosion(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    Grayscale erosion (sliding minimum) of ``input`` by ``kernel``
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    raise NotImplementedError
+
+
+def dilatation(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    Grayscale dilation (sliding maximum) of ``input`` by ``kernel``
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    raise NotImplementedError
+
+
+def opening(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    Opening: erosion followed by dilation.
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    return dilatation(erosion(input_, kernel, border=border), kernel, border=border)
+
+
+def closing(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    "Closing: dilation followed by erosion.
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    return erosion(dilatation(input_, kernel, border=border), kernel, border=border)
+
+
+def gradient(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    Morphological gradient: ``dilate(input) - erode(input)``.
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    return dilatation(input_, kernel, border=border) - erosion(input_, kernel, border=border)
+
+
+def top_hat(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    White top-hat: ``input - open(input)``
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    return input_ - opening(input_, kernel, border=border)
+
+
+def black_hat(input_: torch.Tensor, kernel: torch.Tensor, *, border: BorderMode = BorderMode.REPLICATE) -> torch.Tensor:
+    """
+    Black top-hat: ``close(input) - input``
+    :param input_: input tensor
+    :param kernel: kernel tensor
+    :param border: border mode
+    :return: top-hat tensor
+    """
+    return closing(input_, kernel, border=border) - input_

serron-0.0.1/torch-ext/serron/modules.py

@@ -0,0 +1,66 @@
+"""
+Learnable morphology layers (``torch.nn.Module``).
+"""
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+
+from . import functional as F
+from .enums import BorderMode
+
+
+class _MorphologyNd(nn.Module):
+    """Shared base: owns the learnable SE parameter."""
+
+    def __init__(
+        self,
+        channels: int,
+        kernel_size: int,
+        *,
+        border: BorderMode = BorderMode.REPLICATE,
+        dtype: torch.dtype = torch.float32,
+        device: torch.device | str | None = None,
+    ) -> None:
+        super().__init__()
+        self.channels = channels
+        self.kernel_size = kernel_size
+        self.border = border
+        self.weight = nn.Parameter(torch.empty(channels, kernel_size, kernel_size, dtype=dtype, device=device))
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        with torch.no_grad():
+            self.weight.zero_()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError
+
+
+class Erosion2d(_MorphologyNd):
+    """Learnable 2-D erosion layer."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return F.erosion(x, self.weight, border=self.border)
+
+
+class Dilation2d(_MorphologyNd):
+    """Learnable 2-D dilation layer."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return F.dilatation(x, self.weight, border=self.border)
+
+
+class Opening2d(_MorphologyNd):
+    """Learnable 2-D opening layer."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return F.opening(x, self.weight, border=self.border)
+
+
+class Closing2d(_MorphologyNd):
+    """Learnable 2-D closing layer."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return F.closing(x, self.weight, border=self.border)

serron-0.0.1/torch-ext/serron/structuring_element.py

@@ -0,0 +1,55 @@
+"""
+Structuring-element builders.
+"""
+
+from __future__ import annotations
+
+import torch
+
+
+def square(size: int, *, device: torch.device | str | None = None) -> torch.Tensor:
+    """
+    Square (full) SE of shape ``(size, size)``.
+    :param size: SE size
+    :param device: device to create the SE on
+    :return: SE tensor
+    """
+    raise NotImplementedError
+
+
+def cross(size: int, *, device: torch.device | str | None = None) -> torch.Tensor:
+    """
+    Cross/plus-shaped SE of shape ``(size, size)``.
+    :param size: SE size
+    :param device: device to create the SE on
+    :return: SE tensor"""
+    raise NotImplementedError
+
+
+def disk(radius: int, *, device: torch.device | str | None = None) -> torch.Tensor:
+    """
+    Disk SE of shape ``(2*radius+1, 2*radius+1)``.
+    :param radius: SE radius
+    :param device: device to create the SE on
+    :return: SE tensor
+    """
+    raise NotImplementedError
+
+
+def diamond(radius: int, *, device: torch.device | str | None = None) -> torch.Tensor:
+    """
+    Diamond SE of shape ``(2*radius+1, 2*radius+1)``.
+    :param radius: SE radius
+    :param device: device to create the SE on
+    :return: SE tensor
+    """
+    raise NotImplementedError
+
+
+def from_tensor(weights: torch.Tensor) -> torch.Tensor:
+    """
+    Wrap an arbitrary 2-D tensor as a grayscale SE.
+    :param weights: 2-D tensor of weights
+    :return: SE tensor
+    """
+    raise NotImplementedError