sdf-sampler 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

sdf_sampler/__init__.py

@@ -28,7 +28,7 @@ Example usage:
 
 from sdf_sampler.analyzer import SDFAnalyzer
 from sdf_sampler.config import AnalyzerConfig, SamplerConfig
-from sdf_sampler.io import export_parquet, load_point_cloud
+from sdf_sampler.io import Mesh, export_parquet, load_mesh, load_point_cloud
 from sdf_sampler.models import (
     AlgorithmType,
     AnalysisResult,
@@ -47,7 +47,7 @@ from sdf_sampler.models import (
 )
 from sdf_sampler.sampler import SDFSampler
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 __all__ = [
     # Main classes
@@ -58,6 +58,8 @@ __all__ = [
     "SamplerConfig",
     # I/O
     "load_point_cloud",
+    "load_mesh",
+    "Mesh",
     "export_parquet",
     # Models
     "SignConvention",

sdf_sampler/cli.py

@@ -174,6 +174,14 @@ def add_output_options(parser: argparse.ArgumentParser) -> None:
         default=1000,
         help="Number of surface points to include (default: 1000)",
     )
+    group.add_argument(
+        "--mesh",
+        type=Path,
+        default=None,
+        help="Mesh file for area-weighted surface sampling (PLY/OBJ/STL). "
+             "If provided, surface points are sampled uniformly by surface area "
+             "instead of by vertex count. Recommended for meshes with uneven vertex density.",
+    )
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -418,7 +426,7 @@ def cmd_analyze(args: argparse.Namespace) -> int:
 
 def cmd_sample(args: argparse.Namespace) -> int:
     """Run sample command."""
-    from sdf_sampler import SDFSampler, load_point_cloud
+    from sdf_sampler import SDFSampler, load_mesh, load_point_cloud
 
     if not args.input.exists():
         print(f"Error: Input file not found: {args.input}", file=sys.stderr)
@@ -439,6 +447,19 @@ def cmd_sample(args: argparse.Namespace) -> int:
         print(f"Error loading point cloud: {e}", file=sys.stderr)
         return 1
 
+    # Load mesh for area-weighted surface sampling if provided
+    mesh = None
+    if args.mesh:
+        if args.verbose:
+            print(f"Loading mesh for area-weighted sampling: {args.mesh}")
+        try:
+            mesh = load_mesh(str(args.mesh))
+            if args.verbose:
+                print(f"  Vertices: {len(mesh.vertices):,}, Faces: {len(mesh.faces):,}")
+        except Exception as e:
+            print(f"Error loading mesh: {e}", file=sys.stderr)
+            return 1
+
     if args.verbose:
         print(f"Loading constraints: {args.constraints}")
 
@@ -448,6 +469,9 @@ def cmd_sample(args: argparse.Namespace) -> int:
     if args.verbose:
         print(f"  Constraints: {len(constraints)}")
         print(f"Generating {args.total_samples:,} samples with strategy: {args.strategy}")
+        if args.include_surface_points:
+            mode = "area-weighted" if mesh else "vertex-based"
+            print(f"  Including {args.surface_point_count:,} surface points ({mode})")
 
     config = build_sampler_config(args)
     sampler = SDFSampler(config=config)
@@ -458,14 +482,11 @@ def cmd_sample(args: argparse.Namespace) -> int:
         total_samples=args.total_samples,
         strategy=args.strategy,
         seed=args.seed,
+        include_surface_points=args.include_surface_points,
+        surface_point_count=args.surface_point_count,
+        mesh=mesh,
     )
 
-    # Include surface points if requested
-    if args.include_surface_points:
-        samples = _add_surface_points(
-            samples, xyz, normals, args.surface_point_count, args.verbose
-        )
-
     if args.verbose:
         print(f"Generated {len(samples)} samples")
 
@@ -476,7 +497,7 @@ def cmd_sample(args: argparse.Namespace) -> int:
 
 def cmd_pipeline(args: argparse.Namespace) -> int:
     """Run full pipeline: analyze + sample + export."""
-    from sdf_sampler import SDFAnalyzer, SDFSampler, load_point_cloud
+    from sdf_sampler import SDFAnalyzer, SDFSampler, load_mesh, load_point_cloud
 
     if not args.input.exists():
         print(f"Error: Input file not found: {args.input}", file=sys.stderr)
@@ -497,6 +518,19 @@ def cmd_pipeline(args: argparse.Namespace) -> int:
         print(f"  Points: {len(xyz):,}")
         print(f"  Normals: {'yes' if normals is not None else 'no'}")
 
+    # Load mesh for area-weighted surface sampling if provided
+    mesh = None
+    if args.mesh:
+        if args.verbose:
+            print(f"Loading mesh for area-weighted sampling: {args.mesh}")
+        try:
+            mesh = load_mesh(str(args.mesh))
+            if args.verbose:
+                print(f"  Vertices: {len(mesh.vertices):,}, Faces: {len(mesh.faces):,}")
+        except Exception as e:
+            print(f"Error loading mesh: {e}", file=sys.stderr)
+            return 1
+
     # Analyze
     if args.verbose:
         algos = args.algorithms or ["all"]
@@ -526,6 +560,9 @@ def cmd_pipeline(args: argparse.Namespace) -> int:
     # Sample
     if args.verbose:
         print(f"Generating {args.total_samples:,} samples with strategy: {args.strategy}")
+        if args.include_surface_points:
+            mode = "area-weighted" if mesh else "vertex-based"
+            print(f"  Including {args.surface_point_count:,} surface points ({mode})")
 
     config = build_sampler_config(args)
     sampler = SDFSampler(config=config)
@@ -536,14 +573,11 @@ def cmd_pipeline(args: argparse.Namespace) -> int:
         total_samples=args.total_samples,
         strategy=args.strategy,
         seed=args.seed,
+        include_surface_points=args.include_surface_points,
+        surface_point_count=args.surface_point_count,
+        mesh=mesh,
     )
 
-    # Include surface points if requested
-    if args.include_surface_points:
-        samples = _add_surface_points(
-            samples, xyz, normals, args.surface_point_count, args.verbose
-        )
-
     if args.verbose:
         print(f"Generated {len(samples)} samples")
 
@@ -553,52 +587,6 @@ def cmd_pipeline(args: argparse.Namespace) -> int:
     return 0
 
 
-def _add_surface_points(
-    samples: list,
-    xyz: np.ndarray,
-    normals: np.ndarray | None,
-    count: int,
-    verbose: bool,
-) -> list:
-    """Add surface points to sample list."""
-    from sdf_sampler.models import TrainingSample
-
-    n_surface = min(count, len(xyz))
-    if n_surface <= 0:
-        return samples
-
-    # Subsample if needed
-    if n_surface < len(xyz):
-        indices = np.random.choice(len(xyz), n_surface, replace=False)
-        surface_xyz = xyz[indices]
-        surface_normals = normals[indices] if normals is not None else None
-    else:
-        surface_xyz = xyz
-        surface_normals = normals
-
-    if verbose:
-        print(f"Adding {len(surface_xyz):,} surface points (phi=0)")
-
-    for i in range(len(surface_xyz)):
-        sample = TrainingSample(
-            x=float(surface_xyz[i, 0]),
-            y=float(surface_xyz[i, 1]),
-            z=float(surface_xyz[i, 2]),
-            phi=0.0,
-            weight=1.0,
-            source="surface",
-            is_surface=True,
-            is_free=False,
-        )
-        if surface_normals is not None:
-            sample.nx = float(surface_normals[i, 0])
-            sample.ny = float(surface_normals[i, 1])
-            sample.nz = float(surface_normals[i, 2])
-        samples.append(sample)
-
-    return samples
-
-
 def cmd_info(args: argparse.Namespace) -> int:
     """Show information about a file."""
     if not args.input.exists():

sdf_sampler/io.py

@@ -1,6 +1,7 @@
 # ABOUTME: I/O utilities for point cloud loading and sample export
 # ABOUTME: Supports PLY, LAS/LAZ, CSV, NPZ, and Parquet formats
 
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -10,6 +11,79 @@ import pandas as pd
 from sdf_sampler.models.samples import TrainingSample
 
 
+@dataclass
+class Mesh:
+    """Triangle mesh with vertices, faces, and optional normals.
+
+    Used for area-weighted surface sampling where we need face information.
+    """
+
+    vertices: np.ndarray  # (N, 3) vertex positions
+    faces: np.ndarray  # (M, 3) triangle face indices
+    vertex_normals: np.ndarray | None = None  # (N, 3) per-vertex normals
+
+
+def load_mesh(
+    path: str | Path,
+    **kwargs: Any,
+) -> Mesh:
+    """Load mesh from file (preserves face information).
+
+    Use this instead of load_point_cloud() when you need area-weighted
+    surface sampling, which requires face information.
+
+    Supported formats:
+    - PLY (requires trimesh in [io] extras)
+    - OBJ (requires trimesh in [io] extras)
+    - STL (requires trimesh in [io] extras)
+    - OFF (requires trimesh in [io] extras)
+
+    Args:
+        path: Path to mesh file
+        **kwargs: Additional arguments for trimesh loader
+
+    Returns:
+        Mesh object with vertices, faces, and optional normals
+
+    Example:
+        >>> mesh = load_mesh("model.ply")
+        >>> print(f"Vertices: {len(mesh.vertices)}, Faces: {len(mesh.faces)}")
+    """
+    try:
+        import trimesh
+    except ImportError as e:
+        raise ImportError(
+            "trimesh is required for mesh loading. "
+            "Install with: pip install sdf-sampler[io]"
+        ) from e
+
+    path = Path(path)
+    loaded = trimesh.load(path, **kwargs)
+
+    # Handle Scene objects (multiple meshes)
+    if isinstance(loaded, trimesh.Scene):
+        # Combine all meshes into one
+        meshes = [g for g in loaded.geometry.values() if isinstance(g, trimesh.Trimesh)]
+        if not meshes:
+            raise ValueError(f"No triangle meshes found in {path}")
+        loaded = trimesh.util.concatenate(meshes)
+
+    if not isinstance(loaded, trimesh.Trimesh):
+        raise ValueError(
+            f"File {path} did not load as a triangle mesh. "
+            "Use load_point_cloud() for point cloud files."
+        )
+
+    vertices = np.asarray(loaded.vertices)
+    faces = np.asarray(loaded.faces)
+
+    vertex_normals = None
+    if loaded.vertex_normals is not None and len(loaded.vertex_normals) == len(vertices):
+        vertex_normals = np.asarray(loaded.vertex_normals)
+
+    return Mesh(vertices=vertices, faces=faces, vertex_normals=vertex_normals)
+
+
 def load_point_cloud(
     path: str | Path,
     **kwargs: Any,
@@ -37,8 +111,8 @@ def load_point_cloud(
     path = Path(path)
     suffix = path.suffix.lower()
 
-    if suffix == ".ply":
-        return _load_ply(path, **kwargs)
+    if suffix in (".ply", ".obj", ".stl", ".off"):
+        return _load_mesh_vertices(path, **kwargs)
     elif suffix in (".las", ".laz"):
         return _load_las(path, **kwargs)
     elif suffix == ".csv":
@@ -76,27 +150,33 @@ def export_parquet(
     return path
 
 
-def _load_ply(path: Path, **kwargs: Any) -> tuple[np.ndarray, np.ndarray | None]:
-    """Load PLY file using trimesh."""
+def _load_mesh_vertices(path: Path, **kwargs: Any) -> tuple[np.ndarray, np.ndarray | None]:
+    """Load mesh file using trimesh and return vertices."""
     try:
         import trimesh
     except ImportError as e:
         raise ImportError(
-            "trimesh is required for PLY support. "
+            "trimesh is required for mesh file support. "
             "Install with: pip install sdf-sampler[io]"
         ) from e
 
-    mesh = trimesh.load(path, **kwargs)
+    loaded = trimesh.load(path, **kwargs)
+
+    # Handle Scene objects (multiple meshes)
+    if isinstance(loaded, trimesh.Scene):
+        meshes = [g for g in loaded.geometry.values() if isinstance(g, trimesh.Trimesh)]
+        if meshes:
+            loaded = trimesh.util.concatenate(meshes)
 
     # Handle both PointCloud and Trimesh objects
-    if hasattr(mesh, "vertices"):
-        xyz = np.asarray(mesh.vertices)
+    if hasattr(loaded, "vertices"):
+        xyz = np.asarray(loaded.vertices)
     else:
-        xyz = np.asarray(mesh.points if hasattr(mesh, "points") else mesh)
+        xyz = np.asarray(loaded.points if hasattr(loaded, "points") else loaded)
 
     normals = None
-    if hasattr(mesh, "vertex_normals") and mesh.vertex_normals is not None:
-        normals = np.asarray(mesh.vertex_normals)
+    if hasattr(loaded, "vertex_normals") and loaded.vertex_normals is not None:
+        normals = np.asarray(loaded.vertex_normals)
         if normals.shape != xyz.shape:
             normals = None
 

sdf_sampler/sampler.py

@@ -67,6 +67,7 @@ class SDFSampler:
         seed: int | None = None,
         include_surface_points: bool = False,
         surface_point_count: int | None = None,
+        mesh: Any = None,
     ) -> list[TrainingSample]:
         """Generate training samples from constraints.
 
@@ -79,6 +80,8 @@ class SDFSampler:
             seed: Random seed for reproducibility
             include_surface_points: If True, include original surface points with phi=0
             surface_point_count: Number of surface points to include (default: 1000, or len(xyz) if smaller)
+            mesh: Optional Mesh object for area-weighted surface sampling. If provided,
+                  surface points are sampled uniformly by surface area instead of by vertex.
 
         Returns:
             List of TrainingSample objects
@@ -163,7 +166,7 @@ class SDFSampler:
             # Default to 1000 surface points, or all points if smaller
             count = surface_point_count if surface_point_count is not None else min(1000, len(xyz))
             samples.extend(
-                self._generate_surface_points(xyz, normals, count, rng)
+                self._generate_surface_points(xyz, normals, count, rng, mesh)
             )
 
         return samples
@@ -174,6 +177,7 @@ class SDFSampler:
         normals: np.ndarray | None,
         count: int,
         rng: np.random.Generator,
+        mesh: Any = None,
     ) -> list[TrainingSample]:
         """Generate surface point samples (phi=0) from the input point cloud.
 
@@ -182,10 +186,19 @@ class SDFSampler:
             normals: Optional point normals (N, 3)
             count: Number of surface points to include
             rng: Random number generator
+            mesh: Optional Mesh object for area-weighted sampling
 
         Returns:
             List of TrainingSample objects with phi=0
         """
+        if count <= 0:
+            return []
+
+        # Use area-weighted sampling if mesh is provided
+        if mesh is not None:
+            return self._generate_surface_points_area_weighted(mesh, count, rng)
+
+        # Fallback to vertex-based sampling
         n_surface = min(count, len(xyz))
         if n_surface <= 0:
             return []
@@ -219,6 +232,107 @@ class SDFSampler:
 
         return samples
 
+    def _generate_surface_points_area_weighted(
+        self,
+        mesh: Any,
+        count: int,
+        rng: np.random.Generator,
+    ) -> list[TrainingSample]:
+        """Generate surface points using area-weighted sampling.
+
+        Samples points uniformly by surface area, not by vertex count.
+        This ensures uniform coverage even when vertex density varies.
+
+        Args:
+            mesh: Mesh object with vertices, faces, and optional vertex_normals
+            count: Number of surface points to generate
+            rng: Random number generator
+
+        Returns:
+            List of TrainingSample objects with phi=0
+        """
+        vertices = mesh.vertices
+        faces = mesh.faces
+
+        # Compute face areas
+        v0 = vertices[faces[:, 0]]
+        v1 = vertices[faces[:, 1]]
+        v2 = vertices[faces[:, 2]]
+        face_areas = 0.5 * np.linalg.norm(np.cross(v1 - v0, v2 - v0), axis=1)
+
+        # Sample faces proportional to their area
+        total_area = face_areas.sum()
+        if total_area <= 0:
+            return []
+
+        face_probs = face_areas / total_area
+        sampled_faces = rng.choice(len(faces), size=count, p=face_probs)
+
+        # Sample random point within each selected face using barycentric coordinates
+        # Generate random barycentric coordinates
+        r1 = rng.random(count)
+        r2 = rng.random(count)
+        # Ensure uniform distribution within triangle
+        sqrt_r1 = np.sqrt(r1)
+        u = 1 - sqrt_r1
+        v = sqrt_r1 * (1 - r2)
+        w = sqrt_r1 * r2
+
+        # Get vertices for sampled faces
+        f_v0 = vertices[faces[sampled_faces, 0]]
+        f_v1 = vertices[faces[sampled_faces, 1]]
+        f_v2 = vertices[faces[sampled_faces, 2]]
+
+        # Compute sample positions
+        surface_xyz = (
+            u[:, np.newaxis] * f_v0 +
+            v[:, np.newaxis] * f_v1 +
+            w[:, np.newaxis] * f_v2
+        )
+
+        # Compute normals (interpolated from vertex normals if available, else face normals)
+        if mesh.vertex_normals is not None:
+            n0 = mesh.vertex_normals[faces[sampled_faces, 0]]
+            n1 = mesh.vertex_normals[faces[sampled_faces, 1]]
+            n2 = mesh.vertex_normals[faces[sampled_faces, 2]]
+            surface_normals = (
+                u[:, np.newaxis] * n0 +
+                v[:, np.newaxis] * n1 +
+                w[:, np.newaxis] * n2
+            )
+            # Normalize
+            norms = np.linalg.norm(surface_normals, axis=1, keepdims=True)
+            norms = np.where(norms > 0, norms, 1)
+            surface_normals = surface_normals / norms
+        else:
+            # Compute face normals
+            edge1 = f_v1 - f_v0
+            edge2 = f_v2 - f_v0
+            surface_normals = np.cross(edge1, edge2)
+            norms = np.linalg.norm(surface_normals, axis=1, keepdims=True)
+            norms = np.where(norms > 0, norms, 1)
+            surface_normals = surface_normals / norms
+
+        # Build samples
+        samples = []
+        for i in range(len(surface_xyz)):
+            sample = TrainingSample(
+                x=float(surface_xyz[i, 0]),
+                y=float(surface_xyz[i, 1]),
+                z=float(surface_xyz[i, 2]),
+                phi=0.0,
+                nx=float(surface_normals[i, 0]),
+                ny=float(surface_normals[i, 1]),
+                nz=float(surface_normals[i, 2]),
+                weight=1.0,
+                source="surface",
+                is_surface=True,
+                is_free=False,
+            )
+            samples.append(sample)
+
+        return samples
+
     def to_dataframe(self, samples: list[TrainingSample]) -> pd.DataFrame:
         """Convert samples to pandas DataFrame.
 

sdf_sampler/sampling/box.py

@@ -80,17 +80,18 @@ def sample_box_inverse_square(
     """Generate samples from a box with inverse-square density distribution.
 
     Samples more points near the surface (point cloud) and fewer far away.
+    Uses actual distance to surface for phi values (signed distance).
 
     Args:
         constraint: Box constraint to sample
         rng: Random number generator
-        near_band: Near-band width for offset
+        near_band: Near-band width for density weighting (not phi assignment)
         n_samples: Number of samples to generate
         surface_tree: KDTree of surface points for distance computation
         falloff: Falloff exponent (higher = faster falloff)
 
     Returns:
-        List of TrainingSample objects
+        List of TrainingSample objects with phi = actual signed distance to surface
     """
     samples = []
     center = np.array(constraint.center)
@@ -109,8 +110,11 @@ def sample_box_inverse_square(
         weight = (near_band / min_dist) ** falloff
 
         if rng.random() < min(1.0, weight):
-            offset = near_band if constraint.sign == SignConvention.EMPTY else -near_band
-            phi = offset
+            # Use actual distance to surface for phi, with sign based on constraint type
+            # EMPTY regions have positive phi (outside surface)
+            # SOLID regions have negative phi (inside surface)
+            sign = 1.0 if constraint.sign == SignConvention.EMPTY else -1.0
+            phi = sign * float(dist_to_surface)
 
             samples.append(
                 TrainingSample(

{sdf_sampler-0.4.0.dist-info → sdf_sampler-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdf-sampler
-Version: 0.4.0
+Version: 0.6.0
 Summary: Auto-analysis and sampling of point clouds for SDF (Signed Distance Field) training data generation
 Project-URL: Repository, https://github.com/Chiark-Collective/sdf-sampler
 Author-email: Liam <liam@example.com>

{sdf_sampler-0.4.0.dist-info → sdf_sampler-0.6.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-sdf_sampler/__init__.py,sha256=FHnKJRr5pvXppAkkkofZwF7BE4BZjq1xKeCprQHg_hU,1891
+sdf_sampler/__init__.py,sha256=V0cSSwx_MN5Q6Chmp1_rXKUzul1mPVBLdV3h7nQC24E,1937
 sdf_sampler/__main__.py,sha256=6N7jJs2Efs1AmM7qXXXN9V-ErFTWpPqKzWTeiujtGhU,490
 sdf_sampler/analyzer.py,sha256=bF0jiqJg0tc8H3c6O1f7Ac6tYxsHsT8Y0ShyoRcZnGg,11702
-sdf_sampler/cli.py,sha256=DB6oAYCfH80hSGHt2IgUBa5tNock9HfeB_6Xsea2oDs,20135
+sdf_sampler/cli.py,sha256=wb49roSnPfhX6z9RB8hE88RupJ44Fj7cMDd3gvWmnfQ,20418
 sdf_sampler/config.py,sha256=lrPM1ktFkv32RRtOz6R-ShUFlBZ2LvoAl1hRLThmgKw,5185
-sdf_sampler/io.py,sha256=DfdXJa_2KQhja_T_a-jlVADcAABeF-NR8e3_vnIJHnk,4968
-sdf_sampler/sampler.py,sha256=G_t6o8HpXAP16s_V-dewYt9K_0Bq6Lx1vBPT7udmgMg,17915
+sdf_sampler/io.py,sha256=rGIf9nXGfv8o1AZ6QYm1pibWAraPTBmrEiOOi1cmDZc,7651
+sdf_sampler/sampler.py,sha256=ycizKuy-fy5_y5te2sO-DGyeJF9PCiVNQ-9JgtsbqNs,22058
 sdf_sampler/algorithms/__init__.py,sha256=pp7tSZ8q0zRXZ5S8D3tho7bJ62pmW8jceuuRXtiXIzU,777
 sdf_sampler/algorithms/flood_fill.py,sha256=iWGPPtOPSs0Cg7pxUlXUKGloFNCr8PuCHguRNy3c56c,7042
 sdf_sampler/algorithms/normal_idw.py,sha256=uX3MQDTDX0wVilwxDE9dFj9hm2xuBDHV-AZqspjz7sk,3270
@@ -17,12 +17,12 @@ sdf_sampler/models/analysis.py,sha256=xSzz1jmpV3mOSM4gIF3NR4dhPXPH6UlxIgxZSOke5y
 sdf_sampler/models/constraints.py,sha256=k0v6-JwXmUkFXGycDpPG44amjoRo13xz1ggqdr9NVtE,7316
 sdf_sampler/models/samples.py,sha256=0DD7Z8D70zJKRTq16pik9SgGiRDeXh56EqmBZfql_sk,1474
 sdf_sampler/sampling/__init__.py,sha256=mbeU9DTHxR4R1D4WqjEzaYHq7bV1nSv-wywc3YoD_Lg,492
-sdf_sampler/sampling/box.py,sha256=qRAumR1z_7vU9rfNvk-B6xNu62UeHSyQNghYiTwVR_Y,3912
+sdf_sampler/sampling/box.py,sha256=_CNJ98tl09NegA1XOECEVZWpigwsrAx_nP6cUmNHYR4,4284
 sdf_sampler/sampling/brush.py,sha256=CcAgOYLdYXMM3y_H4fIwyzRJ8PZivFxkUHP7d0ElpNM,1991
 sdf_sampler/sampling/ray_carve.py,sha256=EsfzEGk33q0iWVzOJKDAJi2iWEsY-JZXmEfEZ0dmNdg,4444
 sdf_sampler/sampling/sphere.py,sha256=Xqpwq-RcEnAD6HhoyIC-ErxRHDknDKMtYf6aWUJ43_U,1680
-sdf_sampler-0.4.0.dist-info/METADATA,sha256=o1peEETZNWtfdDyIvd4NIZFm30imYZbPvvbyUAeWH1Y,10481
-sdf_sampler-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sdf_sampler-0.4.0.dist-info/entry_points.txt,sha256=2IMWFbDYEqVUkpiRF1BlRMOhipeirPJSbv5PIOIZrvA,53
-sdf_sampler-0.4.0.dist-info/licenses/LICENSE,sha256=eeB8aLnEG-dgFYs2KqfMJaP52GFQT8sZPHwaYnHRW8E,1061
-sdf_sampler-0.4.0.dist-info/RECORD,,
+sdf_sampler-0.6.0.dist-info/METADATA,sha256=Gi2B0UQmqjula9BBpah3C2WMAjrOk20mcP_EUss_rp0,10481
+sdf_sampler-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sdf_sampler-0.6.0.dist-info/entry_points.txt,sha256=2IMWFbDYEqVUkpiRF1BlRMOhipeirPJSbv5PIOIZrvA,53
+sdf_sampler-0.6.0.dist-info/licenses/LICENSE,sha256=eeB8aLnEG-dgFYs2KqfMJaP52GFQT8sZPHwaYnHRW8E,1061
+sdf_sampler-0.6.0.dist-info/RECORD,,