diffusion-cartogram 0.2.1__tar.gz → 0.2.2__tar.gz

diffusion_cartogram-0.2.2/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## [0.2.2] - 2026-08-31
+
+### New: Additional reconstruction options
+
+- **Added** `load_mesh_topology(mesh_path)`: loads a mesh's own vertices,
+  faces, and per-vertex normals with **no resampling**. This is the new
+  default entry point for the deformation pipeline (replaces `create_pcd` as
+  the "get me surface points" call for most users; `create_pcd` still exists
+  unchanged for anyone who wants a lighter/resampled point cloud, or as the
+  Poisson fallback's input).
+- **Modified** `export_mesh_file(filename, deformed_pcd, ...)`:
+  - New parameters: `method='none'` (new default), `original_faces=None`.
+  - `method='none'`: requires `original_faces`; if given, saves
+    `(deformed_pcd, original_faces)` directly via
+    `pymeshlab.Mesh(vertex_matrix=..., face_matrix=...)` -- no reconstruction. 
+  - If `method='none'` but `original_faces` is `None`: emits a
+    `RuntimeWarning` and **falls back to `method='poisson'`** (the prior,
+    only, behavior) automatically.
+  - `method='poisson'`: unchanged prior behavior (screened Poisson
+    reconstruction with estimated normals), reachable explicitly or via the
+    automatic fallback above.
+  - Added `method='ball_pivoting'` and `method='alpha_shape'` alongside `'none'`/  `'poisson'`. New parameters, all with defaults matching pymeshlab's own except `alpha_filtering`. `ball_radius=0.0` (0% = auto-estimated), `ball_clustering=20.0`, `ball_creasethr=90.0`, `ball_deletefaces=False`, `alpha=1.0`, `alpha_filtering='Alpha Shape'` (pymeshlab's own filter default is `'Alpha Complex'`, deliberately overridden -- `'Alpha Complex'` retains interior simplicial-complex faces, not just the outer boundary).
+  - Backward compatible: existing callers that only ever passed
+    `(filename, deformed_pcd)` keep working exactly as before, just now with
+    a printed warning nudging them toward the no-reconstruction path.
+  
+
+## [0.2.1] - 2026-07-31
+
+### New: Post hoc animation 
+- **`animate_surface_posthoc`** - Interpolate the final displacement field and densities to create an animation for display purposes. Faster than running with tracking but not guaranteed to be accurate at intermediate steps
+- **`animate_map_posthoc`** - Same function implemented for 2D maps
+
+## [0.2.0] - 2026-04-29
+
+### New: 2D VDERM Pipeline
+
+- **`VDERMGrid2D`** — 2-D Lagrangian-Eulerian grid; same physics as `VDERMGrid` (diffusion + gradient advection) with one dimension removed. Compatible with the existing `run_VDERM()` function.
+- **`run_VDERM_2d_with_tracking()`** — tracking run with grid and map-point exports (CSV format: `x y v_x v_y rho` for grid, `x y rho` for map points).
+- **`make_initial_grid_2d()`** / **`compute_grid_dimensions_2d()`** / **`print_grid_info_2d()`** — 2-D grid utilities mirroring the 3-D equivalents.
+- **`interpolate_to_map_2d()`** / **`interpolate_densities_2d()`** / **`interpolate_velocities_2d()`** — 2-D interpolation from grid to arbitrary point sets.
+
+### New: Geographic I/O (`pip install diffusion-cartogram[2D]`)
+
+- **`read_geojson(filepath)`** — extract 2-D point array from GeoJSON (polygon boundaries, point features, line features).
+- **`read_shapefile(filepath)`** — same for Shapefiles.
+- **`read_geotiff(filepath, band=1)`** — read a raster band plus coordinate arrays.
+- **`density_from_geotiff(grid_2d, filepath)`** — sample a GeoTIFF raster onto a `VDERMGrid2D` density field with bilinear interpolation; handles north-up rasters and nodata automatically.
+- **`write_csv_2d()`** / **`read_csv_2d()`** — simple 2-column / 3-column CSV I/O for 2-D point sets.
+
+### New: 2D Visualization
+
+- **`plot_map_2d()`** — scatter plot of 2-D points with optional density colouring.
+- **`plot_density_field_2d()`** — heatmap of the `VDERMGrid2D` density field.
+- **`plot_map_before_after()`** — side-by-side comparison of original and deformed map.
+- **`animate_map_deformation_2d()`** — GIF / MP4 animation from `vderm_map/` CSV exports.
+- **`animate_grid_deformation_2d()`** — GIF / MP4 animation from `vderm_grid/` CSV exports.
+- **`plot_density_evolution_2d()`** — density statistics over iterations.
+
+### Packaging
+
+- Version bumped to **0.2.0**.
+- New optional dependency group **`[2D]`**: geopandas, rasterio, shapely.
+- New optional dependency group **`[3D]`**: pymeshlab.
+- New optional dependency group **`[all]`**: `[2D]` + `[3D]`.
+- `pyproject.toml` now points `readme` at `README_pypi.md` (no embedded GIF) for PyPI; `README.md` remains the full GitHub README.
+
+## [0.1.0] - 2026-02-09
+
+### Initial Release
+
+- Core VDERM algorithm implementation
+- Flexible XYZ file I/O
+- Optional mesh support via PyMeshLab
+- Visualization and animation tools
+- Tracking with intermediate exports
+- ParaView export capabilities
+- Comprehensive example notebooks

diffusion_cartogram-0.2.2/MANIFEST.in

@@ -0,0 +1,23 @@
+# Include essential files
+include README.md
+include LICENSE
+include CHANGELOG.md
+
+# Include package code
+recursive-include diffusion_cartogram *.py
+
+# Exclude examples, tests, and large files
+prune examples
+prune tests
+global-exclude *.stl
+global-exclude *.obj
+global-exclude *.ply
+global-exclude *.xyz
+global-exclude *.gif
+global-exclude *.mp4
+global-exclude *.png
+global-exclude *.jpg
+global-exclude .git*
+global-exclude __pycache__
+global-exclude *.pyc
+global-exclude .DS_Store

{diffusion_cartogram-0.2.1/diffusion_cartogram.egg-info → diffusion_cartogram-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diffusion-cartogram
-Version: 0.2.1
+Version: 0.2.2
 Summary: Volumetric Density-Equalizing Reference Map — 3D shape deformation and 2D cartogram generation
 Author-email: Jonah Spector <spector.jo@northeastern.edu>
 License: MIT License
@@ -56,6 +56,7 @@ Requires-Dist: geopandas>=0.12; extra == "all"
 Requires-Dist: rasterio>=1.3; extra == "all"
 Requires-Dist: shapely>=2.0; extra == "all"
 Requires-Dist: pymeshlab>=2023.12; extra == "all"
+Dynamic: license-file
 
 # diffusion-cartogram 
 [![PyPI version](https://badge.fury.io/py/diffusion-cartogram.svg)](https://badge.fury.io/py/diffusion-cartogram)

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2}/diffusion_cartogram/__init__.py

@@ -29,7 +29,7 @@ cartogram deformation from GeoJSON / Shapefile inputs.
 >>> vd.plot_map_2d(deformed, title='Population Cartogram')
 """
 
-__version__ = '0.2.1'
+__version__ = '0.2.2'
 
 # Core VDERM classes and algorithms
 from .core import (
@@ -44,6 +44,7 @@ from .core import (
     write_xyz,
     read_xyz,
     create_pcd,
+    load_mesh_topology,
     export_mesh_file,
     export_mesh_vtk,
 )
@@ -92,6 +93,7 @@ __all__ = [
     'write_xyz',
     'read_xyz',
     'create_pcd',
+    'load_mesh_topology',
     'export_mesh_file',
     'export_mesh_vtk',
     

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2}/diffusion_cartogram/core.py

@@ -2,6 +2,7 @@ import numpy as np
 from scipy import interpolate
 from tqdm import tqdm
 import os
+import warnings
 from scipy.interpolate import RegularGridInterpolator, NearestNDInterpolator
 try:
     import pymeshlab as ml
@@ -51,10 +52,57 @@ def create_pcd(mesh_path, n_pts=25_000, sampling_method='poisson'):
     current_mesh = ms.current_mesh()
     out = current_mesh.vertex_matrix()
     norms = current_mesh.vertex_normal_matrix()
-    
+
     return out, norms
-    
-            
+
+
+def load_mesh_topology(mesh_path):
+    """
+    Load a mesh's own vertices, faces, and per-vertex normals directly, with
+    no resampling -- unlike create_pcd, which generates an entirely new point
+    cloud unrelated to the mesh's actual vertex/face indices.
+
+    This is the entry point for the "no reconstruction" deformation pipeline:
+    push the returned `vertices` through interpolate_to_surface exactly as you
+    would create_pcd's point cloud, then pass the (still index-aligned)
+    deformed vertices and this function's `faces` to
+    export_mesh_file(..., method='none', original_faces=faces) to export with
+    the source mesh's exact topology preserved -- no reconstruction, and
+    therefore no risk of the reconstruction artifacts (holes, non-manifold
+    surfaces) that Poisson/ball-pivoting/alpha-shape can produce on sparse or
+    thin geometry.
+
+    Parameters
+    ----------
+    mesh_path : str
+        mesh file path
+
+    Returns
+    -------
+    vertices : ndarray, shape (n_verts, 3)
+        Vertex positions [x, y, z], in the mesh's own vertex order.
+    faces : ndarray, shape (n_faces, 3)
+        Triangle vertex-index triples, referencing rows of `vertices`.
+    normals : ndarray, shape (n_verts, 3)
+        Per-vertex normal vectors, in the same order as `vertices`.
+    """
+    _require_pymeshlab('load_mesh_topology')
+
+    ms = ml.MeshSet()
+    ms.load_new_mesh(mesh_path)
+    ms.compute_normal_per_vertex()
+
+    current_mesh = ms.current_mesh()
+    vertices = current_mesh.vertex_matrix()
+    faces = current_mesh.face_matrix()
+    normals = current_mesh.vertex_normal_matrix()
+    norm_len = np.linalg.norm(normals, axis=1, keepdims=True)
+    norm_len[norm_len == 0] = 1
+    normals = normals / norm_len
+
+    return vertices, faces, normals
+
+
 def write_xyz(filepath, positions, normals=None, densities=None):
     """
     Write grid positions (and optionally normal vectors and densities) to space-delimited .xyz file.
@@ -1329,81 +1377,208 @@ def interpolate_to_surface(surface_points, grid_params, displacement_field):
     
     return surface_points + interpolated_displacement
 
-def export_mesh_file(filename, deformed_pcd, depth=8, fulldepth=5, scale=1.1):
+def export_mesh_file(filename, deformed_pcd, method='none', original_faces=None,
+                      depth=8, fulldepth=5, scale=1.1,
+                      ball_radius=0.0, ball_clustering=20.0, ball_creasethr=90.0,
+                      ball_deletefaces=False,
+                      alpha=1.0, alpha_filtering='Alpha Shape'):
     """
-    Creates and exports a Poisson mesh from a deformed point cloud.
-    
-    Normals are automatically estimated from the deformed point cloud geometry
-    using local neighborhood analysis, which is more accurate for deformed surfaces
-    than using original normals.
-    
+    Exports a deformed point cloud/mesh to file, either by reusing known mesh
+    topology directly (default) or by reconstructing a surface from scratch.
+
     Parameters
     ----------
     filename : str
         Output file path (.ply, .stl, .obj, .off, or .gltf/.glb)
     deformed_pcd : ndarray, shape (n_points, 3)
-        Deformed point cloud to remesh
+        Deformed point positions to export.
+    method : str, default='none'
+        'none' -- No reconstruction: save `deformed_pcd` directly with
+            `original_faces` as its triangle connectivity. Requires
+            `original_faces` (see below); if omitted, falls back to
+            method='poisson' automatically (with a warning). Guarantees the
+            same topology/watertightness as the source mesh, since nothing is
+            being reconstructed -- just moving known vertices. Use this when
+            `deformed_pcd` is the deformed version of a mesh's own vertices,
+            e.g. from load_mesh_topology() pushed through
+            interpolate_to_surface().
+
+        The remaining methods are all genuine surface-*reconstruction*
+        fallbacks, only meaningful when `original_faces` isn't available
+        (e.g. `deformed_pcd` came from create_pcd's resampling, or some other
+        point source with no known mesh behind it). All three can leave holes
+        or non-manifold regions on sparse or thin (e.g. wireframe) geometry --
+        prefer method='none' whenever `original_faces` is available, and treat
+        these as a last resort, trying more than one if the first doesn't
+        give a usable result on your specific point cloud:
+
+        'poisson' -- Screened Poisson surface reconstruction, with normals
+            estimated from local neighborhood geometry. Tends to over-smooth
+            and can bridge/merge separate thin features that are close
+            together, but usually produces a closed (watertight) surface even
+            from imperfect data.
+        'ball_pivoting' -- Rolls a virtual ball of radius `ball_radius` over
+            the (normal-estimated) point cloud, adding a triangle everywhere
+            it touches 3 points simultaneously. Preserves sharp features
+            better than Poisson, but requires fairly uniform point density --
+            it leaves holes wherever the ball can't reach (e.g. sparse
+            regions, or thin rods meeting at sharp angles), so it is *not*
+            guaranteed watertight.
+        'alpha_shape' -- Filters the point cloud's Delaunay triangulation down
+            to the faces within `alpha` of the input points (see `alpha` and
+            `alpha_filtering` below). Purely geometric (no normal estimation
+            needed), deterministic, but similarly sensitive to uneven point
+            density and also not guaranteed watertight.
+    original_faces : ndarray, shape (n_faces, 3), optional
+        Required when method='none'. Triangle vertex-index triples, referencing
+        rows of `deformed_pcd` by index -- i.e. `deformed_pcd` must still be in
+        the same vertex order these faces were defined against.
     depth : int, default=8
-        Poisson reconstruction octree depth (higher = more detail)
+        (method='poisson' only) Poisson reconstruction octree depth (higher = more detail)
     fulldepth : int, default=5
-        Depth below which octree will be complete
+        (method='poisson' only) Depth below which octree will be complete
     scale : float, default=1.1
-        Ratio between reconstruction cube diameter and samples' bounding cube diameter
-    
+        (method='poisson' only) Ratio between reconstruction cube diameter and samples' bounding cube diameter
+    ball_radius : float, default=0.0
+        (method='ball_pivoting' only) Pivoting ball radius, as a percentage of
+        the point cloud's bounding-box diagonal. 0.0 asks pymeshlab to
+        auto-estimate a radius from the point cloud's own density.
+    ball_clustering : float, default=20.0
+        (method='ball_pivoting' only) Percentage of `ball_radius` used as a
+        clustering threshold -- points closer together than this are treated
+        as a single point during reconstruction (reduces redundant triangles).
+    ball_creasethr : float, default=90.0
+        (method='ball_pivoting' only) Angle (degrees) beyond which an edge is
+        treated as a crease and not smoothed over.
+    ball_deletefaces : bool, default=False
+        (method='ball_pivoting' only) If True, only add points to the mesh
+        without generating faces (rarely useful; kept for parity with the
+        underlying pymeshlab filter).
+    alpha : float, default=1.0
+        (method='alpha_shape' only) Alpha value, as a percentage of the point
+        cloud's bounding-box diagonal. Larger values include more/coarser
+        faces; smaller values hew closer to the points themselves (and more
+        readily leave holes).
+    alpha_filtering : str, default='Alpha Shape'
+        (method='alpha_shape' only) 'Alpha Shape' keeps only the outer
+        boundary surface (what you almost always want for a printable mesh);
+        'Alpha Complex' also keeps interior simplicial-complex faces, which
+        tends to produce a much larger, messier face count for the same
+        input. (pymeshlab's own filter default is 'Alpha Complex' --
+        deliberately overridden here.)
+
     Returns
     -------
     result_mesh : pymeshlab Mesh
-        The reconstructed mesh object
-    
+        The exported mesh object (topology reused as-is for method='none';
+        reconstructed for the other methods).
+
     Notes
     -----
     Poisson reconstruction default values from:
     https://www.cs.jhu.edu/~misha/Code/PoissonRecon/Version8.0/
-    
-    Normal estimation uses k=20 nearest neighbors with 2 smoothing iterations.
-    Adjust these in the code if needed for your specific geometry.
+
+    Normal estimation (method='poisson'/'ball_pivoting') uses k=20 nearest
+    neighbors with 2 smoothing iterations. Adjust these in the code if needed
+    for your specific geometry.
 
     macOS + conda users may encounter an OpenMP conflict (OMP: Error #15) when
     this function is called, due to pymeshlab's bundled libomp conflicting with
     conda-forge's numpy/scipy. See the Known Issues section of the README for
-    the fix. 
-    
+    the fix.
+
     Examples
     --------
-    >>> # Basic usage
-    >>> mesh = export_mesh_file('output.stl', deformed_points)
-    
-    >>> # Higher quality reconstruction
-    >>> mesh = export_mesh_file('output.ply', deformed_points, depth=10)
+    >>> # Default: no reconstruction, reuse the source mesh's own topology
+    >>> verts, faces, normals = load_mesh_topology('mesh.stl')
+    >>> deformed = interpolate_to_surface(verts, grid_params, displacement_field)
+    >>> mesh = export_mesh_file('output.stl', deformed, original_faces=faces)
+
+    >>> # Reconstruction fallbacks, for when original_faces isn't available
+    >>> mesh = export_mesh_file('output.stl', deformed_points, method='poisson')
+    >>> mesh = export_mesh_file('output.stl', deformed_points, method='ball_pivoting', ball_radius=2.0)
+    >>> mesh = export_mesh_file('output.stl', deformed_points, method='alpha_shape', alpha=2.0)
     """
-    _require_pymeshlab('create_pcd')
-    
-    # Create MeshSet and add point cloud
-    ms = ml.MeshSet()
-    point_cloud_mesh = ml.Mesh(vertex_matrix=deformed_pcd)
-    ms.add_mesh(point_cloud_mesh)
-    
-    # Estimate normals from local geometry of deformed point cloud
-    ms.compute_normal_for_point_clouds(k=20, smoothiter=2)
-    
-    # Perform Poisson surface reconstruction using estimated normals
-    ms.generate_surface_reconstruction_screened_poisson(
-        depth=depth,
-        fulldepth=fulldepth,
-        scale=scale
+    _require_pymeshlab('export_mesh_file')
+
+    if method == 'none' and original_faces is None:
+        warnings.warn(
+            "export_mesh_file(method='none') requires original_faces; "
+            "falling back to method='poisson' (surface reconstruction from "
+            "the point cloud, no known topology to reuse).",
+            RuntimeWarning,
+        )
+        method = 'poisson'
+
+    if method == 'none':
+        ms = ml.MeshSet()
+        ms.add_mesh(ml.Mesh(
+            vertex_matrix=np.asarray(deformed_pcd, dtype=float),
+            face_matrix=np.asarray(original_faces, dtype=np.int32),
+        ))
+        ms.save_current_mesh(filename)
+        return ms.current_mesh()
+
+    if method == 'poisson':
+        # Create MeshSet and add point cloud
+        ms = ml.MeshSet()
+        point_cloud_mesh = ml.Mesh(vertex_matrix=deformed_pcd)
+        ms.add_mesh(point_cloud_mesh)
+
+        # Estimate normals from local geometry of deformed point cloud
+        ms.compute_normal_for_point_clouds(k=20, smoothiter=2)
+
+        # Perform Poisson surface reconstruction using estimated normals
+        ms.generate_surface_reconstruction_screened_poisson(
+            depth=depth,
+            fulldepth=fulldepth,
+            scale=scale
+        )
+
+        # Compute normals for the reconstructed mesh (for smooth rendering)
+        ms.compute_normal_for_point_clouds()
+
+        # Save the mesh to file
+        ms.save_current_mesh(filename)
+
+        # Return the mesh object
+        return ms.current_mesh()
+
+    if method == 'ball_pivoting':
+        ms = ml.MeshSet()
+        ms.add_mesh(ml.Mesh(vertex_matrix=deformed_pcd))
+
+        # Ball pivoting needs oriented normals, same as Poisson
+        ms.compute_normal_for_point_clouds(k=20, smoothiter=2)
+
+        ms.generate_surface_reconstruction_ball_pivoting(
+            ballradius=ml.PercentageValue(ball_radius),
+            clustering=ball_clustering,
+            creasethr=ball_creasethr,
+            deletefaces=ball_deletefaces,
+        )
+
+        ms.save_current_mesh(filename)
+        return ms.current_mesh()
+
+    if method == 'alpha_shape':
+        ms = ml.MeshSet()
+        ms.add_mesh(ml.Mesh(vertex_matrix=deformed_pcd))
+
+        # Purely geometric (Delaunay + circumradius) -- no normals needed
+        ms.generate_alpha_shape(
+            alpha=ml.PercentageValue(alpha),
+            filtering=alpha_filtering,
+        )
+
+        ms.save_current_mesh(filename)
+        return ms.current_mesh()
+
+    raise ValueError(
+        f"Unknown method {method!r}; expected 'none', 'poisson', "
+        f"'ball_pivoting', or 'alpha_shape'"
     )
     
-    # Compute normals for the reconstructed mesh (for smooth rendering)
-    ms.compute_normal_for_point_clouds()
-    
-    # Save the mesh to file
-    ms.save_current_mesh(filename)
-    
-    # Return the mesh object
-    result_mesh = ms.current_mesh()
-    
-    return result_mesh
-    
 def export_mesh_vtk(filepath, deformed_pcd, densities, depth=8):
     """
     Create and export a Poisson mesh in VTK format with density vertex attribute.

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2}/diffusion_cartogram/visualization.py

@@ -236,10 +236,10 @@ def animate_grid_deformation(export_folder='vderm_exports',
 
 
 def animate_surface_deformation(export_folder='vderm_exports',
-                                subfolder='vderm_surface', 
+                                subfolder='vderm_surface',
                                 output_file='surface_animation.gif',
                                 fps=5,
-                                subsample=5000,
+                                subsample=None,
                                 show_normals=False,
                                 alpha=0.6,
                                 figsize=(10, 8)):
@@ -256,13 +256,16 @@ def animate_surface_deformation(export_folder='vderm_exports',
         Output animation filename (.gif or .mp4)
     fps : int, default=5
         Frames per second
-    subsample : int or None, default=5000
-        Subsample to this many points for faster rendering
+    subsample : int or None, default=None
+        If given, subsample to this many points for faster rendering. Default
+        is no subsampling -- use every exported point, for the densest
+        (most informative) animation. Set this if rendering is too slow on a
+        very large point cloud.
     show_normals : bool, default=False
         If True, draw normal vectors (slower, may clutter visualization)
     figsize : tuple, default=(10, 8)
         Figure size in inches
-    
+
     Returns
     -------
     None

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2/diffusion_cartogram.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diffusion-cartogram
-Version: 0.2.1
+Version: 0.2.2
 Summary: Volumetric Density-Equalizing Reference Map — 3D shape deformation and 2D cartogram generation
 Author-email: Jonah Spector <spector.jo@northeastern.edu>
 License: MIT License
@@ -56,6 +56,7 @@ Requires-Dist: geopandas>=0.12; extra == "all"
 Requires-Dist: rasterio>=1.3; extra == "all"
 Requires-Dist: shapely>=2.0; extra == "all"
 Requires-Dist: pymeshlab>=2023.12; extra == "all"
+Dynamic: license-file
 
 # diffusion-cartogram 
 [![PyPI version](https://badge.fury.io/py/diffusion-cartogram.svg)](https://badge.fury.io/py/diffusion-cartogram)

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2}/diffusion_cartogram.egg-info/SOURCES.txt

@@ -1,4 +1,6 @@
+CHANGELOG.md
 LICENSE
+MANIFEST.in
 README.md
 README_pypi.md
 pyproject.toml
@@ -11,9 +13,4 @@ diffusion_cartogram.egg-info/PKG-INFO
 diffusion_cartogram.egg-info/SOURCES.txt
 diffusion_cartogram.egg-info/dependency_links.txt
 diffusion_cartogram.egg-info/requires.txt
-diffusion_cartogram.egg-info/top_level.txt
-tests/test_core.py
-tests/test_core_2d.py
-tests/test_interpolation.py
-tests/test_io.py
-tests/test_vizualization.py
+diffusion_cartogram.egg-info/top_level.txt

{diffusion_cartogram-0.2.1 → diffusion_cartogram-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffusion-cartogram"
-version = "0.2.1"
+version = "0.2.2"
 description = "Volumetric Density-Equalizing Reference Map — 3D shape deformation and 2D cartogram generation"
 readme = "README_pypi.md"
 requires-python = ">=3.8"