Fix zigzag zone boundaries: correct strip generation coordinate math

Root cause: _generate_strip_zones used bounding-box diagonal (~94m) as
the lateral extent for strip rectangles, but UTM coordinates are large
(~781000, ~1435000), so the actual lateral projection values are ~-796000.
The strip rectangles were constructed far from the farm polygon, producing
zero intersections and triggering the legacy Voronoi grid fallback — which
creates the jagged, grid-cell zone boundaries visible in the output.

Fixes:
1. valve_engine._generate_strip_zones: Project polygon onto BOTH the main
and lateral axes to get the true coordinate ranges. Use the actual
lateral projection range (with padding) instead of the bbox diagonal.

2. design_api.py: When crop zones don't cover the full farm, compute the
uncovered area and add it as a 'generic' zone. This ensures strip
generation can tile the entire farm and valve counts stay consistent.

3. valve_engine.generate_valve_zones: Replace the legacy grid fallback
with graceful strip count reconciliation — split the largest strip(s)
when too few, or keep the N largest when too many.

Result: Zones are now clean rectangular strips (5 vertices each) instead
of jagged grid-cell mosaics (9-27 vertices). All 140 tests pass.

Co-Authored-By: Oz <oz-agent@warp.dev>

design_api.py

@@ -13,7 +13,7 @@ import math
 from typing import Dict, List, Any, Tuple, Optional
 
 import pyproj
-from shapely.geometry import Polygon, Point, LineString
+from shapely.geometry import Polygon, Point, LineString, MultiPolygon
 
 import geojson_io as gj_io
 from drip_engine import (
@@ -109,13 +109,35 @@ def process_farm_design(geojson_input: str) -> Dict[str, Any]:
                 "area_m2": zone_utm.area,
             })
 
-        # If no explicit crop zones, treat entire farm as single generic zone
+        # If no explicit crop zones, treat entire farm as single generic zone.
+        # If crop zones exist but don't cover the full farm, add a generic
+        # zone for the uncovered area so strip generation can tile the
+        # entire farm and valve counts stay consistent.
         if not crop_zones_utm:
             crop_zones_utm = [{
                 "crop": "generic",
                 "polygon": farm_utm,
                 "area_m2": farm_utm.area,
             }]
+        else:
+            from shapely.ops import unary_union
+            crop_union = unary_union([z["polygon"] for z in crop_zones_utm])
+            uncovered = farm_utm.difference(crop_union)
+            if not uncovered.is_empty and uncovered.area > farm_utm.area * 0.05:
+                if isinstance(uncovered, MultiPolygon):
+                    for part in uncovered.geoms:
+                        if part.area > farm_utm.area * 0.02:
+                            crop_zones_utm.append({
+                                "crop": "generic",
+                                "polygon": part,
+                                "area_m2": part.area,
+                            })
+                elif isinstance(uncovered, Polygon):
+                    crop_zones_utm.append({
+                        "crop": "generic",
+                        "polygon": uncovered,
+                        "area_m2": uncovered.area,
+                    })
 
         # ── 5. Run valve placement engine with multi-source orchestration ───
         source_contexts = []

valve_engine.py

@@ -561,50 +561,35 @@ def _generate_strip_zones(
     # Perpendicular direction (rotate 90 degrees)
     lateral_direction = (-main_direction[1], main_direction[0])
 
-    # Project farm onto main axis to get span
-    min_proj, max_proj = _project_polygon_onto_axis(farm_polygon, main_direction)
-    axis_span = max_proj - min_proj
-
+    # Project farm onto both axes to get actual coordinate ranges.
+    # Using the bounding-box diagonal as lateral extent fails when UTM
+    # coordinates are large — the strip rectangles end up far from the
+    # actual polygon.  Projecting onto both axes gives the true ranges.
+    min_main, max_main = _project_polygon_onto_axis(farm_polygon, main_direction)
+    min_lat, max_lat = _project_polygon_onto_axis(farm_polygon, lateral_direction)
+
+    axis_span = max_main - min_main
     if axis_span <= 0:
         return []
 
+    # Pad the lateral range so the strip rectangle fully covers the polygon
+    lateral_pad = (max_lat - min_lat) * 0.1 + 10
+
     # Divide into N equal strips along the main axis
     strip_width = axis_span / num_zones
 
     strips = []
     for i in range(num_zones):
-        # Define the strip's bounds along the main axis
-        strip_min = min_proj + i * strip_width
-        strip_max = min_proj + (i + 1) * strip_width
-
-        # Create cutting lines perpendicular to main axis
-        # at strip boundaries. Extend them far enough to cross the farm.
-        bounds = farm_polygon.bounds
-        extent = math.sqrt((bounds[2] - bounds[0]) ** 2 + (bounds[3] - bounds[1]) ** 2)
-
-        # Two cutting lines (perpendicular to main_direction)
-        def create_cutting_line(proj_val):
-            center = (
-                proj_val * main_direction[0],
-                proj_val * main_direction[1],
-            )
-            p1 = (
-                center[0] - lateral_direction[0] * extent,
-                center[1] - lateral_direction[1] * extent,
-            )
-            p2 = (
-                center[0] + lateral_direction[0] * extent,
-                center[1] + lateral_direction[1] * extent,
-            )
-            return LineString([p1, p2])
+        strip_min = min_main + i * strip_width
+        strip_max = min_main + (i + 1) * strip_width
 
-        # Create a bounding box in 2D for this strip
-        # Using a polygon with 4 corners
+        # Build strip rectangle in the (main, lateral) projection space,
+        # then reconstruct world coordinates.
         corner_offsets = [
-            (strip_min, -extent),
-            (strip_max, -extent),
-            (strip_max, extent),
-            (strip_min, extent),
+            (strip_min, min_lat - lateral_pad),
+            (strip_max, min_lat - lateral_pad),
+            (strip_max, max_lat + lateral_pad),
+            (strip_min, max_lat + lateral_pad),
         ]
         strip_corners = [
             (
@@ -748,14 +733,40 @@ def generate_valve_zones(
             strips = [item["polygon"] for item in crop_aware_strips]
         else:
             strips = _generate_strip_zones(farm_polygon, main_direction, num_zones)
+            crop_aware_strips = None
 
-        if len(strips) != num_zones:
-            # Fallback to legacy if strip generation failed
-            return _generate_valve_zones_legacy(farm_polygon, valves)
+        # Reconcile strip count with valve count instead of falling back
+        # to the legacy grid (which produces jagged zone boundaries).
+        if len(strips) == 0:
+            # Complete failure — generate strips over the whole farm
+            strips = _generate_strip_zones(farm_polygon, main_direction, num_zones)
+            crop_aware_strips = None
+
+        if len(strips) < num_zones:
+            # Fewer strips than valves: split the largest strip(s)
+            while len(strips) < num_zones:
+                largest_idx = max(range(len(strips)), key=lambda i: strips[i].area)
+                largest = strips.pop(largest_idx)
+                halves = _generate_strip_zones(largest, main_direction, 2)
+                if len(halves) == 2:
+                    strips.insert(largest_idx, halves[0])
+                    strips.insert(largest_idx + 1, halves[1])
+                else:
+                    strips.insert(largest_idx, largest)
+                    break  # can't split further
+        elif len(strips) > num_zones:
+            # More strips than valves: keep only the N largest
+            strips.sort(key=lambda p: p.area, reverse=True)
+            strips = strips[:num_zones]
+
+        # Final guard: if we still can't match, truncate valves to strips
+        effective_count = min(len(strips), num_zones)
 
         # Assign each strip to a valve (in order along the main axis)
         result = []
-        for index, (valve, strip) in enumerate(zip(valves, strips)):
+        for index in range(effective_count):
+            valve = valves[index]
+            strip = strips[index]
             zone_dict = {
                 "valve_id": valve["id"],
                 "polygon": strip,
@@ -764,12 +775,18 @@ def generate_valve_zones(
             # Propagate crop from valve if available
             if "crop" in valve:
                 zone_dict["crop"] = valve["crop"]
-            elif crop_zones:
+            elif crop_aware_strips and index < len(crop_aware_strips):
                 zone_dict["crop"] = crop_aware_strips[index].get("crop", "generic")
             result.append(zone_dict)
         return result
     else:
-        # Legacy grid-based Voronoi fallback
+        # No direction provided — fall back to strip generation over whole farm
+        strips = _generate_strip_zones(farm_polygon, (1, 0), len(valves))
+        if strips:
+            return [
+                {"valve_id": v["id"], "polygon": s, "area_m2": s.area}
+                for v, s in zip(valves, strips)
+            ]
         return _generate_valve_zones_legacy(farm_polygon, valves)