polyforge 0.1.0a1__tar.gz

polyforge-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dag Wastberg
+
+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.

polyforge-0.1.0a1/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: polyforge
+Version: 0.1.0a1
+Summary: polygon processing and manipulation library built on Shapely - simplification, repair, merging, overlap resolution, and clearance fixing
+Author-email: Dag Wastberg <dwastberg@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dwastberg/polyforge
+Project-URL: Repository, https://github.com/dwastberg/polyforge
+Project-URL: Issues, https://github.com/dwastberg/polyforge/issues
+Project-URL: Changelog, https://github.com/dwastberg/polyforge/releases
+Keywords: geometry,polygon,shapely,gis,spatial,simplification,repair,merge,overlap
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0.1
+Requires-Dist: scipy>=1.15.3
+Requires-Dist: shapely>=2.1.0
+Requires-Dist: simplification>=0.7.14
+Dynamic: license-file
+
+# Polyforge
+
+Polyforge is a focused toolkit for cleaning, simplifying, repairing, and merging planar geometries built on top of Shapely.  It exposes a small set of high-level functions that combine fast NumPy-based vertex processing with STRtree-powered spatial indexing, so you can run the same code on a handful of polygons or on thousands of building footprints.
+
+## Installation
+```bash
+pip install polyforge
+```
+Python 3.10+ with Shapely ≥ 2.1 is required.
+
+## What You Get
+| Area | Highlights |
+| --- | --- |
+| **Simplify & Clean** | `simplify_rdp`, `simplify_vw`, `collapse_short_edges`, `remove_small_holes`, `remove_narrow_holes` |
+| **Clearance Fixing** | `fix_clearance` auto-detects issues (holes too close, spikes, passages) and routes to ops helpers. Individual functions (`fix_hole_too_close`, `fix_narrow_passage`, …) now accept either enums or plain strings (e.g. `strategy="split"`). |
+| **Overlap & Merge** | `split_overlap` for pairs, `remove_overlaps` for batches, `merge_close_polygons` with ops-based strategies (`"simple_buffer"`, `"selective_buffer"`, `"vertex_movement"`, `"boundary_extension"`, `"convex_bridges"`). |
+| **Repair & QA** | `repair_geometry`, `analyze_geometry`, plus the pipeline-driven `robust_fix_geometry` / `robust_fix_batch` that iterate validity → clearance → merge → cleanup steps. |
+| **Core Types** | Strategy enums (MergeStrategy, RepairStrategy, OverlapStrategy, …) remain available, but everything also accepts literal strings; `GeometryConstraints` + shared ops utilities live in `polyforge.ops.*`. |
+
+## Quick Examples
+
+### Simplify & Clean
+```python
+from shapely.geometry import Polygon
+from polyforge import simplify_vwp, remove_small_holes
+
+poly = Polygon([(0, 0), (5, 0.1), (10, 0), (10, 10), (0, 10)])
+poly = simplify_vwp(poly, threshold=0.2)
+poly = remove_small_holes(poly, min_area=1.0)
+```
+
+### Fix Narrow Passages Automatically
+```python
+from polyforge import fix_clearance
+
+improved, info = fix_clearance(complex_poly, min_clearance=1.5, return_diagnosis=True)
+print(info.issue, info.fixed)
+```
+
+### Merge Buildings into Blocks
+```python
+from polyforge import merge_close_polygons
+
+merged = merge_close_polygons(
+    buildings,
+    margin=2.0,
+    merge_strategy="boundary_extension",
+    insert_vertices=True,
+)
+```
+
+### Remove Overlaps at Scale
+```python
+from polyforge import remove_overlaps
+clean = remove_overlaps(parcel_list, overlap_strategy='split')
+```
+
+### Constrain Repairs
+```python
+from polyforge import robust_fix_geometry
+from polyforge.core import GeometryConstraints
+
+constraints = GeometryConstraints(min_clearance=1.0, min_area_ratio=0.9)
+fixed, warn = robust_fix_geometry(polygon, constraints)
+```
+
+## Design Notes
+- **Ops-first architecture** – low-level helpers live in `polyforge/ops/…` (simplify, cleanup, clearance, merge). Public modules are thin wrappers that call these ops so behaviour stays consistent across the library.
+- **Literal-friendly configuration** – strategy parameters accept enums or plain strings (`"selective_buffer"`, `"smooth"`, etc.), making it easy to drive Polyforge from config files or CLI flags.
+- **Pipeline-driven repair** – `robust_fix_geometry` now runs a simple step list (validity → clearance → merge → cleanup) via `polyforge.pipeline.run_steps`, replacing the old transactional stage system.
+- **process_geometry() everywhere** – every simplification/cleanup call is just a NumPy function applied to each vertex array, so Z values are preserved automatically.
+- **STRtree first** – overlap removal, merges, and vertex insertion all walk spatial indexes, keeping runtime roughly O(n log n) even for thousands of polygons.
+
+## Project Layout (high level)
+```
+polyforge/
+  ops/
+    simplify_ops.py        # coordinate-level simplify helpers
+    cleanup_ops.py         # hole removal, sliver cleanup
+    clearance/             # clearance fix primitives
+    merge/ + merge_*       # merge strategies & utilities
+  simplify.py              # thin wrappers over ops.simplify
+  clearance/               # fix_clearance + public wrappers
+  overlap.py               # overlap engine + batch helpers
+  merge/                   # merge orchestrator (calls ops)
+  repair/                  # classic repair + pipeline-based robust fixes
+  core/                    # enums, constraints, geometry/spatial utils
+  pipeline.py              # FixConfig + run_steps helper
+```
+
+### Advanced: Using the ops layer directly
+Most users should stick to the high-level API (`polyforge.simplify`, `polyforge.clearance`, `polyforge.merge`, `polyforge.repair`). If you need to compose Polyforge primitives yourself (custom pipelines, batch transforms, etc.), import the ops helpers:
+
+```python
+from shapely.geometry import Polygon
+from polyforge.process import process_geometry
+from polyforge.ops.simplify_ops import snap_short_edges
+from polyforge.ops.clearance import fix_hole_too_close
+from polyforge.ops.merge import merge_selective_buffer
+
+poly = Polygon([(0, 0), (1, 0.01), (2, 0), (2, 2), (0, 2)])
+
+# Run a raw NumPy transform via process_geometry
+collapsed = process_geometry(poly, snap_short_edges, min_length=0.1, snap_mode="midpoint")
+
+# Call clearance helpers directly (accept enums or strings)
+fixed = fix_hole_too_close(collapsed, min_clearance=1.0, strategy="shrink")
+
+# Use merge strategies without going through merge_close_polygons
+merged = merge_selective_buffer([fixed, fixed.translate(1.5, 0)], margin=0.5, preserve_holes=True)
+```
+
+These ops modules expose the same functions the public API uses internally, so they're ideal for custom workflows or experimentation.
+
+## Running Tests
+```bash
+python -m pytest -q
+```
+The suite asserts all expected warnings, so any output indicates a regression.
+
+That’s it—import what you need from `polyforge` and combine the high-level functions to build your own geometry pipelines.

polyforge-0.1.0a1/README.md

@@ -0,0 +1,121 @@
+# Polyforge
+
+Polyforge is a focused toolkit for cleaning, simplifying, repairing, and merging planar geometries built on top of Shapely.  It exposes a small set of high-level functions that combine fast NumPy-based vertex processing with STRtree-powered spatial indexing, so you can run the same code on a handful of polygons or on thousands of building footprints.
+
+## Installation
+```bash
+pip install polyforge
+```
+Python 3.10+ with Shapely ≥ 2.1 is required.
+
+## What You Get
+| Area | Highlights |
+| --- | --- |
+| **Simplify & Clean** | `simplify_rdp`, `simplify_vw`, `collapse_short_edges`, `remove_small_holes`, `remove_narrow_holes` |
+| **Clearance Fixing** | `fix_clearance` auto-detects issues (holes too close, spikes, passages) and routes to ops helpers. Individual functions (`fix_hole_too_close`, `fix_narrow_passage`, …) now accept either enums or plain strings (e.g. `strategy="split"`). |
+| **Overlap & Merge** | `split_overlap` for pairs, `remove_overlaps` for batches, `merge_close_polygons` with ops-based strategies (`"simple_buffer"`, `"selective_buffer"`, `"vertex_movement"`, `"boundary_extension"`, `"convex_bridges"`). |
+| **Repair & QA** | `repair_geometry`, `analyze_geometry`, plus the pipeline-driven `robust_fix_geometry` / `robust_fix_batch` that iterate validity → clearance → merge → cleanup steps. |
+| **Core Types** | Strategy enums (MergeStrategy, RepairStrategy, OverlapStrategy, …) remain available, but everything also accepts literal strings; `GeometryConstraints` + shared ops utilities live in `polyforge.ops.*`. |
+
+## Quick Examples
+
+### Simplify & Clean
+```python
+from shapely.geometry import Polygon
+from polyforge import simplify_vwp, remove_small_holes
+
+poly = Polygon([(0, 0), (5, 0.1), (10, 0), (10, 10), (0, 10)])
+poly = simplify_vwp(poly, threshold=0.2)
+poly = remove_small_holes(poly, min_area=1.0)
+```
+
+### Fix Narrow Passages Automatically
+```python
+from polyforge import fix_clearance
+
+improved, info = fix_clearance(complex_poly, min_clearance=1.5, return_diagnosis=True)
+print(info.issue, info.fixed)
+```
+
+### Merge Buildings into Blocks
+```python
+from polyforge import merge_close_polygons
+
+merged = merge_close_polygons(
+    buildings,
+    margin=2.0,
+    merge_strategy="boundary_extension",
+    insert_vertices=True,
+)
+```
+
+### Remove Overlaps at Scale
+```python
+from polyforge import remove_overlaps
+clean = remove_overlaps(parcel_list, overlap_strategy='split')
+```
+
+### Constrain Repairs
+```python
+from polyforge import robust_fix_geometry
+from polyforge.core import GeometryConstraints
+
+constraints = GeometryConstraints(min_clearance=1.0, min_area_ratio=0.9)
+fixed, warn = robust_fix_geometry(polygon, constraints)
+```
+
+## Design Notes
+- **Ops-first architecture** – low-level helpers live in `polyforge/ops/…` (simplify, cleanup, clearance, merge). Public modules are thin wrappers that call these ops so behaviour stays consistent across the library.
+- **Literal-friendly configuration** – strategy parameters accept enums or plain strings (`"selective_buffer"`, `"smooth"`, etc.), making it easy to drive Polyforge from config files or CLI flags.
+- **Pipeline-driven repair** – `robust_fix_geometry` now runs a simple step list (validity → clearance → merge → cleanup) via `polyforge.pipeline.run_steps`, replacing the old transactional stage system.
+- **process_geometry() everywhere** – every simplification/cleanup call is just a NumPy function applied to each vertex array, so Z values are preserved automatically.
+- **STRtree first** – overlap removal, merges, and vertex insertion all walk spatial indexes, keeping runtime roughly O(n log n) even for thousands of polygons.
+
+## Project Layout (high level)
+```
+polyforge/
+  ops/
+    simplify_ops.py        # coordinate-level simplify helpers
+    cleanup_ops.py         # hole removal, sliver cleanup
+    clearance/             # clearance fix primitives
+    merge/ + merge_*       # merge strategies & utilities
+  simplify.py              # thin wrappers over ops.simplify
+  clearance/               # fix_clearance + public wrappers
+  overlap.py               # overlap engine + batch helpers
+  merge/                   # merge orchestrator (calls ops)
+  repair/                  # classic repair + pipeline-based robust fixes
+  core/                    # enums, constraints, geometry/spatial utils
+  pipeline.py              # FixConfig + run_steps helper
+```
+
+### Advanced: Using the ops layer directly
+Most users should stick to the high-level API (`polyforge.simplify`, `polyforge.clearance`, `polyforge.merge`, `polyforge.repair`). If you need to compose Polyforge primitives yourself (custom pipelines, batch transforms, etc.), import the ops helpers:
+
+```python
+from shapely.geometry import Polygon
+from polyforge.process import process_geometry
+from polyforge.ops.simplify_ops import snap_short_edges
+from polyforge.ops.clearance import fix_hole_too_close
+from polyforge.ops.merge import merge_selective_buffer
+
+poly = Polygon([(0, 0), (1, 0.01), (2, 0), (2, 2), (0, 2)])
+
+# Run a raw NumPy transform via process_geometry
+collapsed = process_geometry(poly, snap_short_edges, min_length=0.1, snap_mode="midpoint")
+
+# Call clearance helpers directly (accept enums or strings)
+fixed = fix_hole_too_close(collapsed, min_clearance=1.0, strategy="shrink")
+
+# Use merge strategies without going through merge_close_polygons
+merged = merge_selective_buffer([fixed, fixed.translate(1.5, 0)], margin=0.5, preserve_holes=True)
+```
+
+These ops modules expose the same functions the public API uses internally, so they're ideal for custom workflows or experimentation.
+
+## Running Tests
+```bash
+python -m pytest -q
+```
+The suite asserts all expected warnings, so any output indicates a regression.
+
+That’s it—import what you need from `polyforge` and combine the high-level functions to build your own geometry pipelines.

polyforge-0.1.0a1/polyforge/__init__.py

@@ -0,0 +1,154 @@
+"""Polyforge - Polygon processing and manipulation library.
+
+This library provides utilities for processing, simplifying, and manipulating
+polygon geometries using Shapely.
+"""
+
+__version__ = "0.1.0a1"
+
+# Simplification functions
+from .simplify import (
+    simplify_rdp,
+    simplify_vw,
+    simplify_vwp,
+    collapse_short_edges,
+    deduplicate_vertices,
+    remove_small_holes,
+    remove_narrow_holes,
+)
+
+# Clearance fixing functions
+from .clearance import (
+    fix_clearance,
+    fix_hole_too_close,
+    fix_narrow_protrusion,
+    remove_narrow_protrusions,
+    fix_sharp_intrusion,
+    fix_narrow_passage,
+    fix_near_self_intersection,
+    fix_parallel_close_edges,
+)
+
+# Overlap handling functions
+from .overlap import (
+    split_overlap,
+    remove_overlaps,
+    count_overlaps,
+    find_overlapping_groups,
+    resolve_overlap_pair,
+)
+
+# Merge functions
+from .merge import merge_close_polygons
+
+# Topology functions
+from .topology import align_boundaries
+
+# Geometry repair functions
+from .repair import (
+    repair_geometry,
+    analyze_geometry,
+    batch_repair_geometries,
+)
+
+# Robust constraint-aware repair
+from .repair.robust import (
+    robust_fix_geometry,
+    robust_fix_batch,
+)
+
+# Core types (enums)
+from .core import (
+    OverlapStrategy,
+    MergeStrategy,
+    RepairStrategy,
+    CollapseMode,
+)
+
+# Core exceptions
+from .core import (
+    PolyforgeError,
+    ValidationError,
+    RepairError,
+    OverlapResolutionError,
+    MergeError,
+    ClearanceError,
+    ConfigurationError,
+    FixWarning,
+)
+
+# Constraint framework
+from .core import (
+    GeometryConstraints,
+    ConstraintStatus,
+    ConstraintViolation,
+    ConstraintType,
+    MergeConstraints,
+)
+
+__all__ = [
+
+    # Simplification
+    'simplify_rdp',
+    'simplify_vw',
+    'simplify_vwp',
+    'collapse_short_edges',
+    'deduplicate_vertices',
+    'remove_small_holes',
+    'remove_narrow_holes',
+
+    # Clearance fixing
+    'fix_clearance',
+    'fix_hole_too_close',
+    'fix_narrow_protrusion',
+    'remove_narrow_protrusions',
+    'fix_sharp_intrusion',
+    'fix_narrow_passage',
+    'fix_near_self_intersection',
+    'fix_parallel_close_edges',
+
+    # Overlap handling
+    'split_overlap',
+    'remove_overlaps',
+    'count_overlaps',
+    'find_overlapping_groups',
+    'resolve_overlap_pair',
+
+    # Merge
+    'merge_close_polygons',
+
+    # Topology
+    'align_boundaries',
+
+    # Geometry repair
+    'repair_geometry',
+    'analyze_geometry',
+    'batch_repair_geometries',
+
+    # Robust constraint-aware repair
+    'robust_fix_geometry',
+    'robust_fix_batch',
+
+    # Core types (enums)
+    'OverlapStrategy',
+    'MergeStrategy',
+    'RepairStrategy',
+    'CollapseMode',
+
+    # Core exceptions
+    'PolyforgeError',
+    'ValidationError',
+    'RepairError',
+    'OverlapResolutionError',
+    'MergeError',
+    'ClearanceError',
+    'ConfigurationError',
+    'FixWarning',
+
+    # Constraint framework
+    'GeometryConstraints',
+    'ConstraintStatus',
+    'ConstraintViolation',
+    'ConstraintType',
+    'MergeConstraints',
+]

polyforge-0.1.0a1/polyforge/clearance/__init__.py

@@ -0,0 +1,62 @@
+"""Geometry clearance fixing functions.
+
+This module provides functions for fixing geometries with low minimum clearance
+by applying minimal geometric modifications. Each function targets a specific
+type of clearance issue.
+
+The minimum_clearance (from Shapely) represents the smallest distance by which
+a vertex could be moved to create an invalid geometry. Higher values indicate
+more robust, stable geometries.
+"""
+
+# Import public API functions from the ops layer
+from polyforge.ops.clearance import (
+    fix_hole_too_close,
+    fix_narrow_protrusion,
+    fix_sharp_intrusion,
+    remove_narrow_protrusions,
+    fix_narrow_passage,
+    fix_near_self_intersection,
+    fix_parallel_close_edges,
+)
+from .fix_clearance import (
+    fix_clearance,
+    diagnose_clearance,
+    ClearanceIssue,
+    ClearanceDiagnosis,
+    ClearanceFixSummary,
+)
+
+# Import utility functions from ops
+from polyforge.ops.clearance import (
+    _find_nearest_vertex_index,
+    _find_nearest_edge_index,
+    _point_to_segment_distance,
+    _point_to_line_perpendicular_distance,
+    _get_vertex_neighborhood,
+    _calculate_curvature_at_vertex,
+    _remove_vertices_between,
+)
+
+__all__ = [
+    # Main public API
+    'fix_clearance',  # Auto-detection and fixing
+    'diagnose_clearance',  # Diagnosis without fixing
+    'ClearanceIssue',
+    'ClearanceDiagnosis',
+    'ClearanceFixSummary',
+    'fix_hole_too_close',
+    'fix_narrow_protrusion',
+    'remove_narrow_protrusions',
+    'fix_sharp_intrusion',
+    'fix_narrow_passage',
+    'fix_near_self_intersection',
+    'fix_parallel_close_edges',
+    # Utility functions (for advanced users and tests)
+    # '_find_nearest_vertex_index',
+    # '_find_nearest_edge_index',
+    # '_point_to_segment_distance',
+    # '_get_vertex_neighborhood',
+    # '_calculate_curvature_at_vertex',
+    # '_remove_vertices_between',
+]