iarap 0.1.0__tar.gz

iarap-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: iarap
+Version: 0.1.0
+Summary: ARAP regularization for implicit surfaces
+Author-email: Tobias Djuren <t.djuren@tu-berlin.de>, Markus Worchel <m.worchel@tu-berlin.de>, Ugo Finnendahl <finnendahl@tu-berlin.de>, Marc Alexa <marc.alexa@tu-berlin.de>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: licence.txt
+Requires-Dist: torch<2.12,>=2.11
+Dynamic: license-file
+
+![](/assets/teaser.jpg)
+
+
+# ARAP-Regularization-for-Implicit-Surfaces
+
+This is the source code for the paper [As-Rigid-As-Possible Regularization for Implicit Surfaces](https://diglib.eg.org/items/de832211-9ab2-431d-bb2b-cde770a5b5ca), SGP 2026.
+
+## Installation
+
+The only dependency is [pytorch](https://pytorch.org/) (tested with torch 2.11.0 with CUDA 12.8). For the demos that generate results similar to those in the paper (implict surface modeling and Gauss Stylization) further dependencies are required (see `demos/requirements.txt`).
+
+````powershell
+python -m venv .env
+.\.venv\Scripts\Activate.ps1 # depends on your os
+pip install git+https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces.git
+````
+
+## Usage (iarap.arap_energy)
+`iarap.arap_energy` computes the batch-averaged ARAP regularization energy ($\mathcal{L}_{ARAP}$) for a deformation model $\boldsymbol f$.
+
+* Input:
+
+  `f`: deformation function as `torch.nn.Module` $(B, d) \rightarrow (B, d)$
+
+  `samples`: points of shape $(B, d)$ (tested with $d=2$ and $d=3$)
+
+  `l_bend`: bending weight ($\lambda_{bend}$)
+* Output:
+  scalar tensor (mean ARAP energy)
+
+Minimal example:
+
+````python
+import torch
+import iarap
+
+class Identity(torch.nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x
+
+f = Identity()
+samples = torch.randn(1024, 3, device="cuda" if torch.cuda.is_available() else "cpu")
+loss = iarap.arap_energy(f, samples, l_bend=0.1)
+print(loss.item())
+````
+
+## Demos
+
+Please see `./demos/surface_modeling.ipynb` to see how ARAP regularization can be used to model implicit surfaces with user defined handles. In `./demos/gauss_stylization.ipynb` you will find the implict variant of [Gauss Stylization](https://github.com/ugogon/gaussStylization) as described in the paper.
+
+There are multiple pretrained signed distance functions in `./demos/sdfs`. Please note that some sdfs are based on meshes that are under CC-BY.
+
+
+## Citation
+
+If you use the repository, please cite
+```
+@article{10.1111:cgf.70519,
+  journal = {Computer Graphics Forum},
+  title = {{As-Rigid-As-Possible Regularization for Implicit Surfaces}},
+  author = {Djuren, Tobias and 
+    Worchel, Markus and 
+    Finnendahl, Ugo and 
+    Alexa, Marc},
+  year = {2026},
+  publisher = {The Eurographics Association and John Wiley & Sons Ltd.},
+  ISSN = {1467-8659},
+  DOI = {10.1111/cgf.70519}
+}
+```

iarap-0.1.0/README.md

@@ -0,0 +1,70 @@
+![](/assets/teaser.jpg)
+
+
+# ARAP-Regularization-for-Implicit-Surfaces
+
+This is the source code for the paper [As-Rigid-As-Possible Regularization for Implicit Surfaces](https://diglib.eg.org/items/de832211-9ab2-431d-bb2b-cde770a5b5ca), SGP 2026.
+
+## Installation
+
+The only dependency is [pytorch](https://pytorch.org/) (tested with torch 2.11.0 with CUDA 12.8). For the demos that generate results similar to those in the paper (implict surface modeling and Gauss Stylization) further dependencies are required (see `demos/requirements.txt`).
+
+````powershell
+python -m venv .env
+.\.venv\Scripts\Activate.ps1 # depends on your os
+pip install git+https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces.git
+````
+
+## Usage (iarap.arap_energy)
+`iarap.arap_energy` computes the batch-averaged ARAP regularization energy ($\mathcal{L}_{ARAP}$) for a deformation model $\boldsymbol f$.
+
+* Input:
+
+  `f`: deformation function as `torch.nn.Module` $(B, d) \rightarrow (B, d)$
+
+  `samples`: points of shape $(B, d)$ (tested with $d=2$ and $d=3$)
+
+  `l_bend`: bending weight ($\lambda_{bend}$)
+* Output:
+  scalar tensor (mean ARAP energy)
+
+Minimal example:
+
+````python
+import torch
+import iarap
+
+class Identity(torch.nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x
+
+f = Identity()
+samples = torch.randn(1024, 3, device="cuda" if torch.cuda.is_available() else "cpu")
+loss = iarap.arap_energy(f, samples, l_bend=0.1)
+print(loss.item())
+````
+
+## Demos
+
+Please see `./demos/surface_modeling.ipynb` to see how ARAP regularization can be used to model implicit surfaces with user defined handles. In `./demos/gauss_stylization.ipynb` you will find the implict variant of [Gauss Stylization](https://github.com/ugogon/gaussStylization) as described in the paper.
+
+There are multiple pretrained signed distance functions in `./demos/sdfs`. Please note that some sdfs are based on meshes that are under CC-BY.
+
+
+## Citation
+
+If you use the repository, please cite
+```
+@article{10.1111:cgf.70519,
+  journal = {Computer Graphics Forum},
+  title = {{As-Rigid-As-Possible Regularization for Implicit Surfaces}},
+  author = {Djuren, Tobias and 
+    Worchel, Markus and 
+    Finnendahl, Ugo and 
+    Alexa, Marc},
+  year = {2026},
+  publisher = {The Eurographics Association and John Wiley & Sons Ltd.},
+  ISSN = {1467-8659},
+  DOI = {10.1111/cgf.70519}
+}
+```

iarap-0.1.0/iarap/__init__.py

@@ -0,0 +1,3 @@
+from . import sampling
+from .energy import arap_energy
+__all__ = ['arap_energy', 'sampling']

iarap-0.1.0/iarap/__polar_decomposition.py

@@ -0,0 +1,204 @@
+"""
+Polar Decomposition with Stable Gradients for PyTorch
+=====================================================
+
+Computes J = R @ S where R is a proper rotation (det R = +1) and S is symmetric.
+
+Note: This implements the "right polar decomposition with proper rotation",
+which enforces det(R) = +1 rather than allowing improper rotations (reflections).
+As a consequence, S is symmetric but NOT necessarily positive definite. If J has
+a negative determinant, one eigenvalue of S will be negative (S absorbs the
+reflection). The standard polar decomposition (where R may have det = -1) always
+yields S positive semi-definite, but for applications in continuum mechanics and
+geometry processing, the det = +1 convention is typically preferred so that R
+always lives in SO(n).
+
+The backward and forward-mode AD use the closed-form derivative of the polar
+factor. The key equation in the eigenbasis of S:
+
+    Omega_{ab} = (T_{ab} - T_{ba}) / (sigma_a + sigma_b)
+
+This involves only 1/(sigma_a + sigma_b), never 1/(sigma_a - sigma_b),
+so it is perfectly stable when singular values coincide.
+
+WARNING: When det(J) < 0, one of the sigma values is negative (by the flip
+convention). If |sigma_a| = |sigma_b| for a pair with opposite signs, then
+sigma_a + sigma_b = 0 and the derivative is genuinely singular. This reflects
+a real geometric singularity: the polar factor is not differentiable there.
+An optional `eps` parameter clamps the denominator for robustness, but this
+introduces bias in the gradient.
+"""
+
+import torch
+from torch.autograd import Function
+
+
+class PolarDecomposition(Function):
+    generate_vmap_rule = True
+
+    @staticmethod
+    def forward(J, eps=0.0):
+        """
+        Compute polar decomposition J = R @ S with det(R) = +1.
+
+        Args:
+            J: (..., n, n) tensor, must be invertible
+            eps: small value to clamp |sigma_a + sigma_b| away from zero in
+                 the derivative. Only relevant when det(J) < 0 and two singular
+                 values are nearly equal. Default 0.0 (no clamping).
+
+        Returns:
+            R: (..., n, n) proper rotation (orthogonal with det = +1)
+            S: (..., n, n) symmetric (positive definite if det(J) > 0,
+               otherwise one eigenvalue is negative)
+            sigma: (..., n) signed singular values (intermediate, for backward/jvp)
+            V: (..., n, n) right singular vectors (intermediate, for backward/jvp)
+            flip: (..., n) sign of the determinant of R
+        """
+        U, sigma, Vh = torch.linalg.svd(J)
+        V = Vh.mH
+
+        # Ensure det(R) = +1
+        det = torch.det(U @ Vh)
+        flip = torch.ones_like(sigma)
+        flip[..., -1] = torch.sign(det)
+        U = U * flip.unsqueeze(-2)
+        sigma = sigma * flip
+
+        R = U @ Vh
+        S = V @ torch.diag_embed(sigma) @ Vh
+
+        return R, S, sigma, V, flip
+
+    @staticmethod
+    def setup_context(ctx, inputs, output):
+        J, eps = inputs
+        R, S, sigma, V, flip = output
+        ctx.save_for_backward(R, sigma, V)
+        ctx.eps = eps
+        # save as plain attributes for jvp (save_for_backward only
+        # populates saved_tensors for the backward path)
+        ctx.R = R
+        ctx.sigma = sigma
+        ctx.V = V
+        ctx.mark_non_differentiable(sigma, V, flip)
+
+    @staticmethod
+    def _safe_sig_sum(sigma, eps):
+        """Compute sigma_a + sigma_b matrix with optional clamping."""
+        sig_sum = sigma.unsqueeze(-1) + sigma.unsqueeze(-2)
+        if eps > 0:
+            # Clamp absolute value away from zero, preserving sign.
+            # Where sig_sum is exactly zero, use +eps.
+            sign = sig_sum.sign()
+            sign = torch.where(sign == 0, torch.ones_like(sign), sign)
+            sig_sum = torch.where(sig_sum.abs() < eps, sign * eps, sig_sum)
+        return sig_sum
+
+    @staticmethod
+    def jvp(ctx, dJ, _deps):
+        """
+        Forward-mode AD: compute tangents (dR, dS) given tangent dJ.
+
+        From J = R @ S, a perturbation dJ gives:
+            dJ = dR @ S + R @ dS
+
+        Multiplying by R^T:
+            T = R^T @ dJ = Omega @ S + dS
+
+        where Omega = R^T @ dR is antisymmetric.
+
+        In the eigenbasis of S (V-basis):
+            Omega_V_{ab} = (T_V_{ab} - T_V_{ba}) / (sigma_a + sigma_b)  for a != b
+            Omega_V_{aa} = 0
+            dS_V = T_V - Omega_V @ diag(sigma)  (symmetric part)
+        """
+        R = ctx.R
+        sigma = ctx.sigma
+        V = ctx.V
+        sig_sum = PolarDecomposition._safe_sig_sum(sigma, ctx.eps)
+
+        # Transform perturbation into V-basis
+        T = R.mH @ dJ
+        T_V = V.mH @ T @ V
+
+        # Solve for Omega_V (antisymmetric)
+        Omega_V = (T_V - T_V.mH) / sig_sum
+        Omega_V = Omega_V - torch.diag_embed(torch.diagonal(Omega_V, dim1=-2, dim2=-1))
+
+        # dR = R @ V @ Omega_V @ V^T
+        Omega = V @ Omega_V @ V.mH
+        dR = R @ Omega
+
+        # dS = R^T @ dJ - Omega @ S = T - Omega @ S (symmetric)
+        S = V @ torch.diag_embed(sigma) @ V.mH
+        dS = T - Omega @ S
+        # Symmetrize to clean up floating point
+        dS = (dS + dS.mH) / 2
+
+        return dR, dS, None, None, None
+
+    @staticmethod
+    def backward(ctx, dR, dS, dsigma, dV, dflip):
+        R, sigma, V = ctx.saved_tensors
+        sig_sum = PolarDecomposition._safe_sig_sum(sigma, ctx.eps)
+
+        dJ = torch.zeros_like(R)
+
+        if dR is not None:
+            # Forward: dR = R @ V @ Omega_V @ V^T
+            #   where Omega_V_{ab} = (T_V_{ab} - T_V_{ba}) / (sigma_a + sigma_b)
+            #   and T_V = V^T @ R^T @ dJ @ V
+            #
+            # Adjoint: dL/dT_V_{ab} = (G_V_{ab} - G_V_{ba}) / (sigma_a + sigma_b)
+            #   where G_V = V^T @ R^T @ grad_R @ V
+            #   dL/dT_V_{aa} = 0
+            #   dL/dJ = R @ V @ (dL/dT_V) @ V^T
+
+            G_V = V.mH @ R.mH @ dR @ V
+            Phi_V = (G_V - G_V.mH) / sig_sum
+            Phi_V = Phi_V - torch.diag_embed(torch.diagonal(Phi_V, dim1=-2, dim2=-1))
+            dJ = dJ + R @ V @ Phi_V @ V.mH
+
+        if dS is not None:
+            # Forward (V-basis): dS_V_{ab} = alpha_{ab} T_V_{ab} + beta_{ab} T_V_{ba}
+            #   alpha_{ab} = sigma_a / (sigma_a + sigma_b)
+            #   beta_{ab}  = sigma_b / (sigma_a + sigma_b)
+            #
+            # Adjoint: dL/dT_V_{ab} = 2 * H_V_sym_{ab} * sigma_a/(sigma_a+sigma_b) for a!=b
+            #          dL/dT_V_{aa} = H_V_sym_{aa}
+
+            H_V = V.mH @ dS @ V
+            H_V_sym = (H_V + H_V.mH) / 2
+            sig_a = sigma.unsqueeze(-1).expand_as(sig_sum)
+            coeff = 2 * sig_a / sig_sum  # diag = 1 automatically
+            dL_dT_V = H_V_sym * coeff
+            dJ = dJ + R @ V @ dL_dT_V @ V.mH
+
+        return dJ, None  # None for eps (non-tensor argument)
+
+
+def polar_decomposition(J, eps=0.0):
+    """
+    Compute polar decomposition J = R @ S with stable gradients.
+
+    This uses the det(R) = +1 convention, so R is always a proper rotation
+    in SO(n). If det(J) < 0, the reflection is absorbed into S, which will
+    then have one negative eigenvalue.
+
+    Args:
+        J: (..., n, n) tensor, must be invertible
+        eps: clamp |sigma_a + sigma_b| to be at least eps in the derivative.
+             Only needed when det(J) < 0 and two singular values are nearly
+             equal. Introduces gradient bias but prevents explosion.
+             Default 0.0 (no clamping; exact gradients).
+
+    Returns:
+        R: (..., n, n) proper rotation (det = +1)
+        S: (..., n, n) symmetric (positive definite iff det(J) > 0)
+        sigma: (..., n) signed singular values (intermediate, for backward/jvp)
+        flip: (..., n) sign of the determinant of R
+    """
+    R, S, _, _, flip = PolarDecomposition.apply(J, eps)
+    return R, S, flip
+

iarap-0.1.0/iarap/energy.py

@@ -0,0 +1,50 @@
+from typing import Literal
+import torch
+from . import __polar_decomposition
+
+
+def arap_energy(f: torch.nn.Module, samples: torch.Tensor, l_bend: float, bending_type: Literal['Chao', 'SR'] = 'Chao') -> torch.Tensor:
+  """
+  Computes the mean ARAP regularization energy on a batch of sample points.
+  See Sec. 3.2 in the paper and demo/surface_modeling.ipynb for an example.
+  #TODO maybe not return values as mean but tensor and also return axiliaries J, R, etc.
+
+  Args:
+    f: Deformation ``f(x) -> y`` as torch.nn.Module takes the samples
+      as input and returns the deformed samples as tensor with the same shape.
+    samples: Tensor of shape ``(B, d)`` containing surface points.
+    l_bend: Scalar weight for the bending term.
+    bending_type: Bending model:
+      - ``"Chao"``: use the bending energy from Chao et al. (2010).
+      - ``"SR"``: use the bending energy from Levi and Gotsman (2014).
+
+  Returns:
+    Scalar tensor containing the batch-averaged ARAP energy.
+
+  Notes:
+    - Uses Jacobians from ``torch.func.jacrev`` and batch evaluation via
+      ``torch.func.vmap``.
+  """
+  d = samples.size(-1) # dimension
+
+  def deformation(x: torch.Tensor) -> torch.Tensor:
+    y = f(x)
+    return y, y
+  samples_jac, samples_deformed = torch.func.vmap(torch.func.jacrev(deformation, has_aux=True))(samples)
+  singular_values = torch.linalg.svdvals(samples_jac)
+
+  def rotation(samples: torch.Tensor) -> torch.Tensor:
+    J = torch.func.jacrev(lambda x: f(x))(samples)
+    R, Y, flip = __polar_decomposition.polar_decomposition(J)
+    return R, (R, Y, flip)
+  dR, (R, Y, flip) = torch.func.vmap(torch.func.jacrev(lambda x: rotation(x), has_aux=True), randomness='different')(samples)
+
+  # stretch energy
+  arap_stretch_loss = (singular_values * flip.detach() - 1).pow(2).mean()
+
+  # bending energy
+  if bending_type == 'Chao':
+    arap_bend_loss = (dR * torch.einsum('buvx,bvw->buwx', dR, Y)).mean() * d**3
+  elif bending_type == 'SR':
+    arap_bend_loss = dR.pow(2).mean() * d**3
+  return arap_stretch_loss + l_bend * arap_bend_loss

iarap-0.1.0/iarap/sampling.py

@@ -0,0 +1,174 @@
+'''
+This code is taken from Ling et al. 2025 - Uniform Sampling of Surfaces by Casting Rays
+and modified e.g. to work with other dimensions, dtypes, devices as well as removed class structure.
+'''
+
+import torch 
+import numpy as np
+
+def sphere_trace_modified(origin: torch.Tensor, direction: torch.Tensor, sdf_fn, max_t, dim=3, eps=1e-4, step_bound=10, dtype=torch.float, device='cuda'):
+    all_pts = []
+    all_pts_hit = []
+    sdf_cost = 0
+    
+    origin = origin.to(dtype=dtype, device=device)
+    direction = direction.to(dtype=dtype, device=device)
+
+    p = origin + 0*direction
+    d = sdf_fn(p).squeeze(-1)
+    t = torch.zeros(d.shape, dtype=dtype, device=device)
+    
+    iter = 0
+    delta = torch.abs(d)
+    not_converged = (t < max_t) # march every ray till the end 
+    while iter < 2000 and torch.any(not_converged): 
+        
+        # add samples near surface and step over the surface for these samples 
+        p_near_surface = (t < max_t) & (delta < eps)
+        if torch.any(p_near_surface):
+            p_hits = torch.ones_like(p)
+            p_hits[p_near_surface] = p[p_near_surface]
+            all_pts.append(p_hits)
+            all_pts_hit.append(p_near_surface)
+            
+            # gather samples near surface 
+            p_near = p[p_near_surface]
+            delta_near = delta[p_near_surface]
+            t_near = t[p_near_surface]
+            max_t_near = max_t[p_near_surface]
+            directions_near = direction[p_near_surface]
+            
+            # p_near_before = p_near.clone()
+            # Keep stepping until delta > eps
+            not_flipped = (t_near < max_t_near) & (delta_near < eps)
+            while torch.any(not_flipped):
+            
+                # Take a step for the samples not flipped yet 
+                p_near_not_flipped = p_near[not_flipped]
+                delta_near_not_flipped = delta_near[not_flipped]
+                t_near_not_flipped = t_near[not_flipped]
+                
+                # Take a step of size max( delta_near_not_flipped, eps/2 ) so that it doesn't get stuck with too small a step.
+                p_near_not_flipped = p_near_not_flipped + torch.maximum(delta_near_not_flipped[:,None], torch.ones_like(delta_near_not_flipped)[:,None] * eps/2.0) * directions_near[not_flipped]
+                t_near_not_flipped = t_near_not_flipped + torch.maximum(delta_near_not_flipped, torch.ones_like(delta_near_not_flipped) * eps/2.0)
+        
+                # Measure distance at new location
+                with torch.no_grad():
+                    delta_near_not_flipped = sdf_fn(p_near_not_flipped).squeeze(-1)
+                sdf_cost += p_near_not_flipped.shape[0]
+                delta_near_not_flipped = torch.abs(delta_near_not_flipped)
+                
+                # Copy back to these near surface samples 
+                p_near[not_flipped] = p_near_not_flipped
+                t_near[not_flipped] = t_near_not_flipped
+                delta_near[not_flipped] = delta_near_not_flipped
+                
+                # Evaluate whether every sample is flipped 
+                not_flipped = (t_near < max_t_near) & (delta_near < eps)
+            
+            # after flipping these samples to the other side of the surface, put those samples back with updated t and delta 
+            p[p_near_surface] = p_near
+            delta[p_near_surface] = delta_near
+            t[p_near_surface] = t_near
+        
+        nc_far = not_converged
+        p_far = p[nc_far,:]
+        d_far = d[nc_far]
+        delta_far = delta[nc_far]
+        t_far = t[nc_far]
+
+        # Take a step
+        p_far = p_far + delta_far[:,None]/step_bound * direction[nc_far,:]
+        t_far = t_far + delta_far/step_bound
+
+        # Measure distance at new location
+        with torch.no_grad():
+            d_far = sdf_fn(p_far).squeeze(-1)
+            
+        sdf_cost += p_far.shape[0]
+        delta_far = torch.abs(d_far)
+
+        # Copy back to original tensors
+        p[nc_far,:] = p_far
+        d[nc_far] = d_far
+        delta[nc_far] = delta_far
+        t[nc_far] = t_far
+
+        iter += 1
+        not_converged = t < max_t
+        
+    if len(all_pts) > 0:
+        all_pts = torch.stack(all_pts, dim=-2) # 5000, 480, 3
+        all_pts_hit = torch.stack(all_pts_hit, dim=-1) # 5000, 480
+        pts = all_pts.view(-1,dim)[all_pts_hit.view(-1)]
+        return pts, sdf_cost
+    else: 
+        return torch.zeros((0,dim), dtype=torch.float, device=device), sdf_cost
+    
+        
+def sample_rays(num_rays, dim=3):
+    # sample line directions 
+    dirs = np.random.randn(num_rays,dim)
+    dirs = dirs / np.linalg.norm(dirs,axis=-1)[:,None] #[n,dim]
+    dirs = dirs[:,None,:] #[n,1,3]
+    
+    # find the other normal and binormal basis 
+    _,_,V = np.linalg.svd(dirs) 
+    E = V[:,:,1:] #[n,3,2] 
+    
+    # sample random offsets in normal and binormal directions
+    dirs = dirs[:,0,:] 
+    U = np.sqrt(dim) * ( np.random.uniform(0,1,(num_rays,1,dim-1)) * 2.0 - 1.0 )  
+    O = np.sum(U * E, axis=-1) 
+    O = O + dirs * np.sqrt(dim)
+    
+    # determine if the ray O+D*t  intersects the [-1,1]^dim hypercube
+    # using Slab method
+    t_low = np.zeros((num_rays,dim))
+    t_high = np.zeros((num_rays,dim))
+    t_low = (-1.0 - O)/dirs 
+    t_high = (1.0 - O)/dirs
+    
+    t_close = np.minimum(t_low, t_high)
+    t_far = np.maximum(t_low,t_high)
+    t_close = np.max(t_close, axis=-1)
+    t_far = np.min(t_far,axis=-1)
+    t = np.stack([t_close, t_far],axis=-1)
+    keep = t_close < t_far
+    
+    dirs = dirs[keep]
+    O = O[keep]
+    t_close = t_close[keep]
+    t_far = t_far[keep]
+    O = O + dirs * t_close[:,None]
+    T = t_far - t_close 
+    n_current = O.shape[0]
+    
+    if (not np.any(keep)) and n_current > num_rays:
+        return np.zeros((0,3)),np.zeros((0,3)),np.zeros((0))
+    elif n_current == num_rays:
+        return O, dirs, T
+    elif n_current < num_rays: 
+        O_current, D_current,T_current = sample_rays(num_rays-n_current, dim=dim)
+        O = np.concatenate([O,O_current],axis=0)
+        D = np.concatenate([dirs,D_current],axis=0)
+        T = np.concatenate([T,T_current],axis=0)
+        return O, D, T 
+
+def uniform_sample(sdf_func, num_rays, dim=3, thresh=1e-4, dtype=torch.float, device='cuda'): 
+    lines_origins, lines_dirs, max_ts = sample_rays(num_rays, dim=dim)     
+    lines_origins = torch.from_numpy(lines_origins).to(dtype=dtype, device=device)
+    lines_dirs = torch.from_numpy(lines_dirs).to(dtype=dtype, device=device)
+    pts, _ = sphere_trace_modified(lines_origins, 
+                                    lines_dirs, 
+                                    sdf_fn=sdf_func, 
+                                    max_t=torch.from_numpy(max_ts).to(dtype=dtype, device=device),
+                                    dim=dim,
+                                    eps=thresh,
+                                    dtype=dtype,
+                                    device=device
+                                    ) 
+    return pts 
+
+  
+        

iarap-0.1.0/iarap.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: iarap
+Version: 0.1.0
+Summary: ARAP regularization for implicit surfaces
+Author-email: Tobias Djuren <t.djuren@tu-berlin.de>, Markus Worchel <m.worchel@tu-berlin.de>, Ugo Finnendahl <finnendahl@tu-berlin.de>, Marc Alexa <marc.alexa@tu-berlin.de>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: licence.txt
+Requires-Dist: torch<2.12,>=2.11
+Dynamic: license-file
+
+![](/assets/teaser.jpg)
+
+
+# ARAP-Regularization-for-Implicit-Surfaces
+
+This is the source code for the paper [As-Rigid-As-Possible Regularization for Implicit Surfaces](https://diglib.eg.org/items/de832211-9ab2-431d-bb2b-cde770a5b5ca), SGP 2026.
+
+## Installation
+
+The only dependency is [pytorch](https://pytorch.org/) (tested with torch 2.11.0 with CUDA 12.8). For the demos that generate results similar to those in the paper (implict surface modeling and Gauss Stylization) further dependencies are required (see `demos/requirements.txt`).
+
+````powershell
+python -m venv .env
+.\.venv\Scripts\Activate.ps1 # depends on your os
+pip install git+https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces.git
+````
+
+## Usage (iarap.arap_energy)
+`iarap.arap_energy` computes the batch-averaged ARAP regularization energy ($\mathcal{L}_{ARAP}$) for a deformation model $\boldsymbol f$.
+
+* Input:
+
+  `f`: deformation function as `torch.nn.Module` $(B, d) \rightarrow (B, d)$
+
+  `samples`: points of shape $(B, d)$ (tested with $d=2$ and $d=3$)
+
+  `l_bend`: bending weight ($\lambda_{bend}$)
+* Output:
+  scalar tensor (mean ARAP energy)
+
+Minimal example:
+
+````python
+import torch
+import iarap
+
+class Identity(torch.nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x
+
+f = Identity()
+samples = torch.randn(1024, 3, device="cuda" if torch.cuda.is_available() else "cpu")
+loss = iarap.arap_energy(f, samples, l_bend=0.1)
+print(loss.item())
+````
+
+## Demos
+
+Please see `./demos/surface_modeling.ipynb` to see how ARAP regularization can be used to model implicit surfaces with user defined handles. In `./demos/gauss_stylization.ipynb` you will find the implict variant of [Gauss Stylization](https://github.com/ugogon/gaussStylization) as described in the paper.
+
+There are multiple pretrained signed distance functions in `./demos/sdfs`. Please note that some sdfs are based on meshes that are under CC-BY.
+
+
+## Citation
+
+If you use the repository, please cite
+```
+@article{10.1111:cgf.70519,
+  journal = {Computer Graphics Forum},
+  title = {{As-Rigid-As-Possible Regularization for Implicit Surfaces}},
+  author = {Djuren, Tobias and 
+    Worchel, Markus and 
+    Finnendahl, Ugo and 
+    Alexa, Marc},
+  year = {2026},
+  publisher = {The Eurographics Association and John Wiley & Sons Ltd.},
+  ISSN = {1467-8659},
+  DOI = {10.1111/cgf.70519}
+}
+```

iarap-0.1.0/iarap.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+licence.txt
+pyproject.toml
+iarap/__init__.py
+iarap/__polar_decomposition.py
+iarap/energy.py
+iarap/sampling.py
+iarap.egg-info/PKG-INFO
+iarap.egg-info/SOURCES.txt
+iarap.egg-info/dependency_links.txt
+iarap.egg-info/requires.txt
+iarap.egg-info/top_level.txt

iarap-0.1.0/iarap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

iarap-0.1.0/iarap.egg-info/requires.txt

@@ -0,0 +1 @@
+torch<2.12,>=2.11

iarap-0.1.0/iarap.egg-info/top_level.txt

@@ -0,0 +1 @@
+iarap

iarap-0.1.0/licence.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

iarap-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "iarap"
+version = "0.1.0"
+authors = [
+  { name="Tobias Djuren", email="t.djuren@tu-berlin.de" },
+  { name="Markus Worchel", email="m.worchel@tu-berlin.de" },
+  { name="Ugo Finnendahl", email="finnendahl@tu-berlin.de" },
+  { name="Marc Alexa", email="marc.alexa@tu-berlin.de" }
+]
+description = "ARAP regularization for implicit surfaces"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "torch>=2.11,<2.12",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://gitlab.com/tobidju/arap-regularization-for-implicit-surfaces"
+
+[tool.setuptools]
+packages = ["iarap"]

iarap-0.1.0/setup.cfg

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