pottslab 1.0.0__tar.gz

pottslab-1.0.0/.github/workflows/build_wheels.yml

@@ -0,0 +1,126 @@
+name: Build and publish wheels
+
+on:
+  push:
+    tags:
+      - "v*"          # run on version tags, e.g. v1.0.1
+  workflow_dispatch:  # allow manual runs from the Actions UI
+
+jobs:
+  # ── Build platform wheels ──────────────────────────────────────────────────
+  build_wheels:
+    name: Build ${{ matrix.target }} wheel
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux — x86_64 (manylinux, covers most servers and desktops)
+          - os: ubuntu-latest
+            target: x86_64
+            manylinux: auto
+
+          # Linux — aarch64 (Raspberry Pi, AWS Graviton, Apple M-series via
+          # emulation; QEMU is set up automatically by maturin-action)
+          - os: ubuntu-latest
+            target: aarch64
+            manylinux: auto
+
+          # macOS — Apple Silicon
+          # Intel macOS (macos-13) was dropped: GitHub-hosted Intel runners are
+          # being retired and queue depth made the job time out at the 24h
+          # maximum. Intel-Mac users can install from the sdist.
+          - os: macos-14
+            target: aarch64
+
+          # Windows — x86_64
+          - os: windows-latest
+            target: x86_64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # Native Windows/macOS runners only have one Python on PATH by default,
+      # so maturin's --interpreter 3.9..3.13 lookup fails. Pre-installing all
+      # five versions via setup-python adds them to PATH. The manylinux
+      # container build skips this step (the host setup doesn't reach inside
+      # the container, which already ships every CPython we need).
+      - name: Set up Python (native runners only)
+        if: matrix.manylinux != 'auto'
+        uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.9
+            3.10
+            3.11
+            3.12
+            3.13
+
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: ${{ matrix.manylinux || '' }}
+          # Build for every supported CPython interpreter.
+          # PyPy is excluded because PyO3 support requires extra setup.
+          args: >-
+            --release
+            --out dist
+            --interpreter 3.9 3.10 3.11 3.12 3.13
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.target }}-${{ matrix.os }}
+          path: dist/*.whl
+
+  # ── Build source distribution ──────────────────────────────────────────────
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+
+      - name: Upload sdist artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  # ── Publish to PyPI ────────────────────────────────────────────────────────
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [build_wheels, build_sdist]
+    # Only publish on version-tag pushes, not on workflow_dispatch
+    if: startsWith(github.ref, 'refs/tags/v')
+    # Requires an environment named "pypi" configured in the repo settings
+    # with PyPI as a trusted publisher (no API token needed).
+    environment:
+      name: pypi
+      url: https://pypi.org/project/pottslab/
+    permissions:
+      id-token: write   # required for OIDC trusted publishing
+
+    steps:
+      - name: Download all wheel and sdist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        # Uses PyPI OIDC trusted publishing — no API token required.
+        # Set up at: https://pypi.org/manage/account/publishing/
+        # Project name: pottslab
+        # Owner:        mstorath
+        # Repository:   Pottslab
+        # Workflow:     build_wheels.yml
+        # Environment:  pypi

pottslab-1.0.0/.gitignore

@@ -0,0 +1,29 @@
+# Rust build artifacts
+target/
+Cargo.lock.bak
+
+# Compiled Python extension (platform-specific; built by CI)
+pottslab/_core*.so
+pottslab/_core*.pyd
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+
+# macOS
+.DS_Store
+
+# Distribution / packaging
+dist/
+*.egg-info/
+.eggs/
+
+# Editors / IDEs
+.vscode/
+.idea/
+*.swp
+
+# Jupyter
+.ipynb_checkpoints/

pottslab-1.0.0/Auxiliary/Operators/convop.m

@@ -0,0 +1,30 @@
+classdef convop < double
+%convop A class for circular convolution by FFT
+    
+% written by M. Storath
+% $Date: 2014-05-07 11:42:11 +0200 (Mi, 07. Mai 2014) $	$Revision: 89 $
+
+    
+    methods
+        % constructor
+        function obj = convop(fourier)
+            obj = obj@double(fourier);
+        end
+        
+        % ctranspose (')
+        function C = ctranspose(A)
+            C = convop(conj(A));
+        end
+        
+        % mtimes (*)
+        function C = mtimes( A, B )
+            if isa(B, 'convop')
+                C = convop( A .* B );
+            else
+                C = ifftn( A .* fftn(B) );
+            end
+        end
+        
+    end
+end
+

pottslab-1.0.0/Auxiliary/Operators/linop.m

@@ -0,0 +1,66 @@
+classdef linop
+%linop A class for linear operators
+    
+% written by M. Storath
+% $Date: 2015-10-15 15:07:43 +0200 (Do, 15. Okt 2015) $	$Revision: 132 $
+
+    
+    properties
+        % function handle for evaluation A * x
+        eval;
+        % function handle for evaluation A' * x
+        ctrans;
+        % A'A
+        normalOp;
+        % true if A'A positive definite
+        posdef;
+        % true if A'A positive definite
+        lseSolver;
+    end
+    
+    methods
+        % constructor
+        function A = linop(eval, ctrans, varargin)
+            % if it is a matrix
+            if ~isa(eval, 'function_handle') 
+                A.eval = @(x) eval * x;
+                A.ctrans = @(x) eval' * x;
+                M = eval' * eval;
+                A.normalOp = @(x) M * x;
+            else
+                A.eval = eval;
+                A.ctrans = ctrans;
+                A.normalOp = @(x) A.ctrans(A.eval(x));
+            end
+            ip = inputParser;
+            addParamValue(ip, 'posdef', false);
+            addParamValue(ip, 'lseSolver', []);
+            parse(ip, varargin{:});
+            par = ip.Results;
+            A.posdef = par.posdef;
+            A.lseSolver = par.lseSolver;
+        end
+        
+        % ctranspose (')
+        function C = ctranspose(A)
+            C =  linop(A.ctrans, A.eval);
+        end
+        
+        % mtimes (*)
+        function C = mtimes( A, B )
+            if isa(B, 'linop')
+                C = linop( @(x) A.eval(B.eval(x)), @(x) B.ctrans(A.ctrans(x)));
+            else
+                C = A.eval(B);
+            end
+        end
+        
+        % size
+        function s = size(A)
+            %warning('Size is deprecated for class linop');
+            s = [1 1];
+        end
+        
+    end
+end
+

pottslab-1.0.0/Auxiliary/Operators/radonop.m

@@ -0,0 +1,25 @@
+classdef radonop < linop
+    %radonop A class for Radon transform
+    
+    % written by M. Storath
+    % $Date: 2014-09-02 14:56:23 +0200 (Di, 02. Sep 2014) $	$Revision: 105 $
+    
+    properties
+        % solution method for prox
+        useFBP;
+    end
+    
+    methods
+        % constructor
+        function A = radonop(theta, imgSize)
+            
+            eval = @(x) radon(x, theta);
+            ctrans = @(x) iradon(x, theta, 'linear', 'None', 1, imgSize);
+            
+            A = A@linop(eval, ctrans);
+            A.posdef = true;
+            A.useFBP = false;
+        end
+    end
+end
+

pottslab-1.0.0/Auxiliary/convkernel.m

@@ -0,0 +1,46 @@
+function h = convkernel( type, n, scale )
+%CONVKERNEL Creates a convolution kernel
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+if not(exist('scale', 'var'))
+   scale = 1; 
+end
+
+% set coordinates
+d = n/2;
+x = linspace(-d, d, n)/scale;
+
+switch type
+    case 'box'
+        h = ones(n, 1);
+        
+    case 'hat'
+        h(x >= 0) = 1-x(x >= 0);
+        h(x < 0) = 1 + x(x < 0);
+        h(abs(x) > 1) = 0; 
+        
+    case 'gaussian'
+        h = exp(-0.5 * x.^2);
+        
+    case 'doubleexp'
+        h = exp(-0.5 * abs(x));
+        
+    case 'mollifier'
+        h = exp(-1./(1 - abs(x).^2));
+        h(abs(x) > 1) = 0;
+        
+    case 'ramp'
+        h(x >= 0) = 1-x(x >= 0);
+        h(abs(x) > 1) = 0; 
+        
+    otherwise
+        error('This option does not exist.')
+end
+
+% normalize
+h = h(:)./sum(h);
+
+end
+

pottslab-1.0.0/Auxiliary/countJumps.m

@@ -0,0 +1,6 @@
+function j = countJumps( f )
+%COUNTJUMPS Counts the jumps of a vector f
+j = sum( diff(f) ~= 0);
+
+end
+

pottslab-1.0.0/Auxiliary/energyL2Potts.m

@@ -0,0 +1,66 @@
+function [energy, jumpPenalty, dataError] = energyL2Potts( u, f, gamma, A, isotropic )
+%energyL2Potts Computes the energy of the L2 Potts functional
+
+if exist('A', 'var') && not(isempty(A))
+    Au = A * u;
+    dataError = sum((Au(:) - f(:)).^2);
+else
+    dataError = sum((u(:) - f(:)).^2);
+end
+
+
+if isvector(u)
+    % vectors
+    jumpPenalty = sum(diff(u(:)) ~= 0);
+else
+    % matrices
+    nJumpComp = 0; % jumps in compass directions
+    nJumpDiag = 0; % jumps in diagonal directions
+    
+    % count jumps
+    for i = 1:size(u, 1)
+        for j = 1:size(u, 2)-1
+            if ~all((u(i,j,:) == u(i,j+1,:)))
+                nJumpComp = nJumpComp + 1;
+            end
+        end
+    end
+    for i = 1:size(u, 1)-1
+        for j = 1:size(u, 2)
+            if ~all((u(i,j,:) == u(i+1,j,:)))
+                nJumpComp = nJumpComp + 1;
+            end
+        end
+    end
+    for i = 1:size(u, 1)-1
+        for j = 1:size(u, 2)-1
+            if ~all((u(i,j,:) == u(i+1,j+1,:)))
+                nJumpDiag = nJumpDiag + 1;
+            end
+        end
+    end
+    for i = 1:size(u, 1)-1
+        for j = 2:size(u, 2)
+            if ~all((u(i,j,:) == u(i+1,j-1,:)))
+                nJumpDiag = nJumpDiag + 1;
+            end
+        end
+    end
+    
+    % set weights (isotropic by default)
+    if ~exist('isotropic', 'var') || isotropic
+        omega1 = sqrt(2) - 1;
+        omega2 = 1 - sqrt(2)/2;
+    else
+        omega1 = 1;
+        omega2 = 0;
+    end
+    
+    % compute energy
+    jumpPenalty = (omega1 * nJumpComp + omega2* nJumpDiag);
+    
+end
+
+energy = gamma * jumpPenalty + dataError;
+
+end

pottslab-1.0.0/Auxiliary/intmatrix.m

@@ -0,0 +1,13 @@
+function A = intmatrix( n )
+%INTMATRIX Creates a matrix that acts as integration 
+% (cumulative sum) on the input vector
+%
+% Au = cumsum(u)
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+A = tril(ones(n));
+
+end
+

pottslab-1.0.0/Auxiliary/medianw.m

@@ -0,0 +1,21 @@
+function mu = medianw( data, weight )
+% medianw Computes a weighted median of the data
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+if numel(data) == 1
+    mu = data;
+else
+    [dataSorted, idx] = sort(data);
+    weightSorted = weight(idx);
+    weightSum = sum(weight);
+    cumWeight = cumsum(weightSorted)/weightSum;
+    % find first median index 
+    idx = find(cumWeight < 0.5, 1, 'last' ) + 1;
+    if isempty(idx)
+       idx = 1; 
+    end
+    mu = dataSorted(idx);
+end
+

pottslab-1.0.0/Auxiliary/plimage2double.m

@@ -0,0 +1,7 @@
+function img = plimage2double( plimg )
+%PLIMAGE2DOUBLE Summary of this function goes here
+%   Detailed explanation goes here
+img = reshape(plimg.toDouble(), [plimg.mRow, plimg.mCol, plimg.mLen]);
+
+end
+

pottslab-1.0.0/Auxiliary/plpsnr.m

@@ -0,0 +1,10 @@
+function r = plpsnr( groundTruth, signal )
+%plPSNR Computes the peak signal to noise ratio
+
+% written by M. Storath
+% $Date: 2014-05-07 14:23:10 +0200 (Mi, 07. Mai 2014) $	$Revision: 90 $
+
+mse = mean(abs(signal(:) - groundTruth(:)).^2);
+r = 10 * log10(max(groundTruth(:))^2 / mse);
+
+end

pottslab-1.0.0/Auxiliary/psnr.m

@@ -0,0 +1,13 @@
+function r = psnr( groundTruth, signal )
+%PSNR Computes the peak signal to noise ratio
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+warning('The function psnr conflicts with the new function psnr from the image processing toolbox from Matlab v2014a. Use plpsnr instead.')
+
+mse = mean(abs(signal(:) - groundTruth(:)).^2);
+r = 10 * log10(max(groundTruth(:))^2 / mse);
+
+end
+

pottslab-1.0.0/Auxiliary/randidx.m

@@ -0,0 +1,11 @@
+function idx = randidx( siz, fraction )
+%randidx Selects randomly a fraction of indices for a matrix of size siz
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+n = prod(siz);
+idx = randperm(n) ;
+idx = idx(1:round(fraction * n));
+end
+

pottslab-1.0.0/Auxiliary/randl.m

@@ -0,0 +1,11 @@
+function y = randl( varargin )
+%randl Random normal Laplacian noise, mean = 0, variance sigma^2 = 1
+% pdf: $\frac{1}{\sqrt{2}} e^{- \sqrt{2} |x|}$
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+x = rand( varargin{:} ) - 0.5;
+y = -sign(x) .* log(1 - 2 * abs(x)) / sqrt(2);
+end
+

pottslab-1.0.0/Auxiliary/samplesToWeights.m

@@ -0,0 +1,20 @@
+function weights = samplesToWeights( samples )
+%samplesToWeights Computes weights from a set of sample points
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+%init
+weights = zeros(size(samples));
+
+% first and last weight
+weights(1) = samples(2) - samples(1);
+weights(end) = samples(end) - samples(end-1);
+
+% central weights
+subs = 2:numel(samples)-1;
+weights(subs) = 0.5 * ( abs(samples(subs) - samples(subs-1)) ...
+    + abs(samples(subs) - samples(subs+1)) );
+
+end
+

pottslab-1.0.0/Auxiliary/segToLabel.m

@@ -0,0 +1,26 @@
+function labelImg = segToLabel(u, conn)
+%SEGTOLABEL Converts the output image of a segmentation function (e.g. minL2Potts2DADMM) to a
+%label image with integer labels (each connected component gets a unique integer)
+% u: image to label (typically the output of minL2Potts2DADMM))
+% conn: connectivity as in bwconncomp (default: 8)
+
+if ~exist('conn', 'var')
+    conn = 8;
+end
+
+[m,n,c] = size(u);
+vals = unique(reshape(u, m*n, c), 'rows');
+labelImg = zeros(m, n);
+labelCounter = 0;
+for i=1:size(vals,1)
+    bw_mult = (vals(i,:) == reshape(u, m*n, c));
+    bw = bw_mult(:,1);
+    CC = bwconncomp(reshape(double(bw), m, n), conn);
+    for j = 1:CC.NumObjects
+        labelImg(CC.PixelIdxList{j}) = labelCounter;
+        labelCounter = labelCounter + 1;
+    end
+end
+
+end
+

pottslab-1.0.0/Auxiliary/setPLJavaPath.m

@@ -0,0 +1,40 @@
+function setPLJavaPath(static)
+
+% the path
+jpath = fullfile( fileparts(which(mfilename)), '..', 'Java', 'bin');
+
+% dynamic path
+javaaddpath(jpath);
+
+% static path
+if exist('static', 'var') && static
+    % static path (is faster, requires restart to take effect)
+    upath = userpath;
+    jpathfile = fullfile(upath, 'javaclasspath.txt');
+    disp(['Appending java class path to ' jpathfile]);
+    pathExists = false;
+    % check if path exists
+    currentPath = javaclasspath('-static');
+    
+    for i = 1:numel(currentPath)
+        pathExists = strcmp(currentPath{i}, jpath) || pathExists;
+    end
+    % append path to classpath
+    if ~pathExists
+        try
+            fid = fopen(jpathfile, 'at');
+            fprintf(fid, '\n');
+            % windows path need double backslash
+            jpath = strrep(jpath,'\','\\');
+            fprintf(fid, jpath);
+            fclose(fid);
+        catch
+            warning('Failed to add java path to static class path. Using dynamic classpath instead. This requires you to call setPLJavaPath.m each time you use Pottslab.')
+        end
+    end
+end
+
+
+
+end
+

pottslab-1.0.0/Auxiliary/showPotts.m

@@ -0,0 +1,30 @@
+function showPotts(data, rec, groundTruth, method)
+%showPotts Display result of Potts reconstructions
+
+subplot(1,2,1)
+plot(data, '.', 'MarkerSize', 10)
+title('Data')
+
+% reconstruction
+subplot(1,2,2)
+plot(rec, '.', 'MarkerSize', 10)
+
+% legend
+if ~exist('method', 'var')
+    leg = {'Reconstruction'};
+else
+    leg = {method};
+end
+
+% add groundTruth
+if exist('groundTruth', 'var')
+    hold on
+    plot(groundTruth, '--r')
+    hold off
+    leg = [leg, {'Ground truth'}];
+    title(['PSNR: ' num2str(plpsnr(groundTruth, rec)), ', #Jumps: ', num2str(countJumps(rec))] );
+end
+
+legend(leg);
+
+end

pottslab-1.0.0/Auxiliary/showSparse.m

@@ -0,0 +1,34 @@
+function showSparse(data, rec, groundTruth, method)
+%showSparse Display result of sparse reconstructions
+
+% written by M. Storath
+% $Date: 2012/10/29 01:19:08 $	$Revision: 0.1 $
+
+% data
+subplot(1,2,1)
+plot(data)
+title('Data')
+
+% reconstruction
+subplot(1,2,2)
+plot(rec, '.', 'MarkerSize', 10)
+
+% legend
+if ~exist('method', 'var')
+    leg = {'Reconstruction'};
+else
+    leg = {method};
+end
+
+% add groundTruth
+if exist('groundTruth', 'var')
+    hold on
+    stem(groundTruth, 'r')
+    hold off
+    leg = [leg, {'Ground truth'}];
+    title(['PSNR: ' num2str(plpsnr(groundTruth, rec))] );
+end
+
+legend(leg);
+
+end