Update pygeos/mcp_output/mcp_plugin/mcp_service.py

pygeos/mcp_output/mcp_plugin/mcp_service.py

@@ -1,44 +1,746 @@
+import os
+import sys
+from typing import List, Optional
+
 from fastmcp import FastMCP
+import numpy as np
+import pygeos
 
 # Create the FastMCP service application
 mcp = FastMCP("pygeos_service")
 
-@mcp.tool(name="list_geometries", description="List all available geometry types in PyGEOS")
-def list_geometries() -> dict:
+# ==================== Geometry Creation ====================
+
+@mcp.tool()
+def create_point(x: float, y: float, z: Optional[float] = None) -> dict:
+    """Create a point geometry from coordinates.
+    
+    Args:
+        x: X coordinate
+        y: Y coordinate
+        z: Optional Z coordinate for 3D point
+    
+    Returns:
+        dict: WKT representation of the created point
+    """
+    try:
+        if z is not None:
+            coords = [[x, y, z]]
+        else:
+            coords = [[x, y]]
+        point = pygeos.points(coords)[0]
+        wkt = pygeos.to_wkt(point)
+        return {"success": True, "wkt": wkt, "geometry_type": "Point"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def create_linestring(coordinates: List[List[float]]) -> dict:
+    """Create a linestring geometry from a list of coordinates.
+    
+    Args:
+        coordinates: List of [x, y] or [x, y, z] coordinate pairs, e.g. [[0, 0], [1, 1], [2, 0]]
+    
+    Returns:
+        dict: WKT representation of the created linestring
     """
-    List all available geometry types in PyGEOS.
+    try:
+        coords = np.array(coordinates)
+        linestring = pygeos.linestrings([coords])[0]
+        wkt = pygeos.to_wkt(linestring)
+        return {"success": True, "wkt": wkt, "geometry_type": "LineString"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
 
+@mcp.tool()
+def create_polygon(shell: List[List[float]], holes: Optional[List[List[List[float]]]] = None) -> dict:
+    """Create a polygon geometry from shell and optional holes.
+    
+    Args:
+        shell: List of coordinates forming the exterior ring, e.g. [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]
+        holes: Optional list of hole rings
+    
     Returns:
-    - dict: A dictionary with success status and list of geometry types.
+        dict: WKT representation of the created polygon
     """
     try:
-        from pygeos import GeometryType
-        geometries = [g.name for g in GeometryType]
+        shell_ring = pygeos.linearrings([np.array(shell)])[0]
+        if holes:
+            hole_rings = [pygeos.linearrings([np.array(h)])[0] for h in holes]
+            polygon = pygeos.polygons(shell_ring, hole_rings)
+        else:
+            polygon = pygeos.polygons(shell_ring)
+        wkt = pygeos.to_wkt(polygon)
+        return {"success": True, "wkt": wkt, "geometry_type": "Polygon"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def create_box(xmin: float, ymin: float, xmax: float, ymax: float) -> dict:
+    """Create a rectangular polygon (box) from bounds.
+    
+    Args:
+        xmin: Minimum X coordinate
+        ymin: Minimum Y coordinate
+        xmax: Maximum X coordinate
+        ymax: Maximum Y coordinate
+    
+    Returns:
+        dict: WKT representation of the box polygon
+    """
+    try:
+        box = pygeos.box(xmin, ymin, xmax, ymax)
+        wkt = pygeos.to_wkt(box)
+        return {"success": True, "wkt": wkt, "geometry_type": "Polygon"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def from_wkt(wkt: str) -> dict:
+    """Parse a WKT string into a geometry and return its properties.
+    
+    Args:
+        wkt: Well-Known Text representation of geometry
+    
+    Returns:
+        dict: Geometry properties including type, validity, and bounds
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        geom_type = pygeos.get_type_id(geom)
+        type_names = {0: "Point", 1: "LineString", 2: "LinearRing", 3: "Polygon",
+                      4: "MultiPoint", 5: "MultiLineString", 6: "MultiPolygon", 7: "GeometryCollection"}
+        bounds = pygeos.bounds(geom).tolist()
         return {
             "success": True,
-            "geometries": geometries,
-            "count": len(geometries)
+            "wkt": pygeos.to_wkt(geom),
+            "geometry_type": type_names.get(int(geom_type), "Unknown"),
+            "is_valid": bool(pygeos.is_valid(geom)),
+            "is_empty": bool(pygeos.is_empty(geom)),
+            "bounds": {"xmin": bounds[0], "ymin": bounds[1], "xmax": bounds[2], "ymax": bounds[3]}
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="create_geometry", description="Create a geometry object in PyGEOS")
-def create_geometry(wkt: str) -> dict:
+
+# ==================== Measurement ====================
+
+@mcp.tool()
+def calculate_distance(wkt1: str, wkt2: str) -> dict:
+    """Calculate the Cartesian distance between two geometries.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Distance between the geometries
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        distance = float(pygeos.distance(geom1, geom2))
+        return {"success": True, "distance": distance}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def calculate_area(wkt: str) -> dict:
+    """Calculate the area of a polygon geometry.
+    
+    Args:
+        wkt: WKT of the polygon geometry
+    
+    Returns:
+        dict: Area of the polygon
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        area = float(pygeos.area(geom))
+        return {"success": True, "area": area}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def calculate_length(wkt: str) -> dict:
+    """Calculate the length of a linear geometry.
+    
+    Args:
+        wkt: WKT of the linear geometry (LineString, MultiLineString, or polygon boundary)
+    
+    Returns:
+        dict: Length of the geometry
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        length = float(pygeos.length(geom))
+        return {"success": True, "length": length}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_bounds(wkt: str) -> dict:
+    """Get the bounding box of a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: Bounding box coordinates (xmin, ymin, xmax, ymax)
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        bounds = pygeos.bounds(geom).tolist()
+        return {
+            "success": True,
+            "xmin": bounds[0],
+            "ymin": bounds[1],
+            "xmax": bounds[2],
+            "ymax": bounds[3]
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def hausdorff_distance(wkt1: str, wkt2: str) -> dict:
+    """Calculate the Hausdorff distance between two geometries.
+    
+    The Hausdorff distance is a measure of the maximum distance between
+    the nearest points in two geometries.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Hausdorff distance
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        dist = float(pygeos.hausdorff_distance(geom1, geom2))
+        return {"success": True, "hausdorff_distance": dist}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Predicates ====================
+
+@mcp.tool()
+def check_intersects(wkt1: str, wkt2: str) -> dict:
+    """Check if two geometries intersect.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Boolean indicating intersection
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.intersects(geom1, geom2))
+        return {"success": True, "intersects": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_contains(wkt1: str, wkt2: str) -> dict:
+    """Check if geometry 1 contains geometry 2.
+    
+    Args:
+        wkt1: WKT of the container geometry
+        wkt2: WKT of the contained geometry
+    
+    Returns:
+        dict: Boolean indicating containment
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.contains(geom1, geom2))
+        return {"success": True, "contains": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_within(wkt1: str, wkt2: str) -> dict:
+    """Check if geometry 1 is within geometry 2.
+    
+    Args:
+        wkt1: WKT of the inner geometry
+        wkt2: WKT of the outer geometry
+    
+    Returns:
+        dict: Boolean indicating if geometry 1 is within geometry 2
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.within(geom1, geom2))
+        return {"success": True, "within": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_touches(wkt1: str, wkt2: str) -> dict:
+    """Check if two geometries touch (share boundary but not interior).
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Boolean indicating if geometries touch
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.touches(geom1, geom2))
+        return {"success": True, "touches": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_crosses(wkt1: str, wkt2: str) -> dict:
+    """Check if two geometries cross each other.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Boolean indicating if geometries cross
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.crosses(geom1, geom2))
+        return {"success": True, "crosses": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_overlaps(wkt1: str, wkt2: str) -> dict:
+    """Check if two geometries overlap.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Boolean indicating if geometries overlap
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.overlaps(geom1, geom2))
+        return {"success": True, "overlaps": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def check_disjoint(wkt1: str, wkt2: str) -> dict:
+    """Check if two geometries are disjoint (do not interact).
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: Boolean indicating if geometries are disjoint
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = bool(pygeos.disjoint(geom1, geom2))
+        return {"success": True, "disjoint": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def is_valid(wkt: str) -> dict:
+    """Check if a geometry is valid.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: Boolean indicating validity and reason if invalid
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        valid = bool(pygeos.is_valid(geom))
+        reason = pygeos.is_valid_reason(geom) if not valid else None
+        return {"success": True, "is_valid": valid, "reason": reason}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def is_simple(wkt: str) -> dict:
+    """Check if a geometry is simple (no self-intersection).
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: Boolean indicating if geometry is simple
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        result = bool(pygeos.is_simple(geom))
+        return {"success": True, "is_simple": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Constructive Operations ====================
+
+@mcp.tool()
+def buffer_geometry(wkt: str, distance: float, quad_segs: int = 8) -> dict:
+    """Create a buffer around a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+        distance: Buffer distance (positive for expansion, negative for erosion)
+        quad_segs: Number of segments for quarter circle approximation
+    
+    Returns:
+        dict: WKT of the buffered geometry
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        buffered = pygeos.buffer(geom, distance, quadsegs=quad_segs)
+        wkt_result = pygeos.to_wkt(buffered)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def simplify_geometry(wkt: str, tolerance: float, preserve_topology: bool = True) -> dict:
+    """Simplify a geometry using Douglas-Peucker algorithm.
+    
+    Args:
+        wkt: WKT of the geometry
+        tolerance: Simplification tolerance
+        preserve_topology: Whether to preserve topology
+    
+    Returns:
+        dict: WKT of the simplified geometry
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        simplified = pygeos.simplify(geom, tolerance, preserve_topology=preserve_topology)
+        wkt_result = pygeos.to_wkt(simplified)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_centroid(wkt: str) -> dict:
+    """Get the centroid of a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: WKT of the centroid point
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        centroid = pygeos.centroid(geom)
+        wkt_result = pygeos.to_wkt(centroid)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_convex_hull(wkt: str) -> dict:
+    """Get the convex hull of a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: WKT of the convex hull
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        hull = pygeos.convex_hull(geom)
+        wkt_result = pygeos.to_wkt(hull)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_envelope(wkt: str) -> dict:
+    """Get the envelope (bounding box) of a geometry as a polygon.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: WKT of the envelope polygon
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        envelope = pygeos.envelope(geom)
+        wkt_result = pygeos.to_wkt(envelope)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_boundary(wkt: str) -> dict:
+    """Get the boundary of a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: WKT of the boundary
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        boundary = pygeos.boundary(geom)
+        wkt_result = pygeos.to_wkt(boundary)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def make_valid(wkt: str) -> dict:
+    """Make an invalid geometry valid.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: WKT of the valid geometry
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        valid_geom = pygeos.make_valid(geom)
+        wkt_result = pygeos.to_wkt(valid_geom)
+        return {"success": True, "wkt": wkt_result, "is_valid": bool(pygeos.is_valid(valid_geom))}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Set Operations ====================
+
+@mcp.tool()
+def geometry_intersection(wkt1: str, wkt2: str) -> dict:
+    """Compute the intersection of two geometries.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: WKT of the intersection
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = pygeos.intersection(geom1, geom2)
+        wkt_result = pygeos.to_wkt(result)
+        return {"success": True, "wkt": wkt_result, "is_empty": bool(pygeos.is_empty(result))}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def geometry_union(wkt1: str, wkt2: str) -> dict:
+    """Compute the union of two geometries.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: WKT of the union
     """
-    Create a geometry object from a WKT string.
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = pygeos.union(geom1, geom2)
+        wkt_result = pygeos.to_wkt(result)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
 
-    Parameters:
-    - wkt: Well-Known Text representation of the geometry
 
+@mcp.tool()
+def geometry_difference(wkt1: str, wkt2: str) -> dict:
+    """Compute the difference of two geometries (wkt1 - wkt2).
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the geometry to subtract
+    
     Returns:
-    - dict: Information about the created geometry
+        dict: WKT of the difference
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = pygeos.difference(geom1, geom2)
+        wkt_result = pygeos.to_wkt(result)
+        return {"success": True, "wkt": wkt_result, "is_empty": bool(pygeos.is_empty(result))}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def geometry_symmetric_difference(wkt1: str, wkt2: str) -> dict:
+    """Compute the symmetric difference of two geometries.
+    
+    Args:
+        wkt1: WKT of the first geometry
+        wkt2: WKT of the second geometry
+    
+    Returns:
+        dict: WKT of the symmetric difference
+    """
+    try:
+        geom1 = pygeos.from_wkt(wkt1)
+        geom2 = pygeos.from_wkt(wkt2)
+        result = pygeos.symmetric_difference(geom1, geom2)
+        wkt_result = pygeos.to_wkt(result)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Linear Operations ====================
+
+@mcp.tool()
+def line_interpolate_point(wkt: str, distance: float, normalized: bool = False) -> dict:
+    """Interpolate a point along a line at a given distance.
+    
+    Args:
+        wkt: WKT of the line geometry
+        distance: Distance along the line (or fraction if normalized)
+        normalized: If True, distance is treated as fraction (0-1)
+    
+    Returns:
+        dict: WKT of the interpolated point
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        point = pygeos.line_interpolate_point(geom, distance, normalized=normalized)
+        wkt_result = pygeos.to_wkt(point)
+        return {"success": True, "wkt": wkt_result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def line_locate_point(line_wkt: str, point_wkt: str, normalized: bool = False) -> dict:
+    """Find the distance along a line to the nearest point.
+    
+    Args:
+        line_wkt: WKT of the line geometry
+        point_wkt: WKT of the point
+        normalized: If True, return fraction (0-1) instead of distance
+    
+    Returns:
+        dict: Distance or fraction along the line
+    """
+    try:
+        line = pygeos.from_wkt(line_wkt)
+        point = pygeos.from_wkt(point_wkt)
+        distance = float(pygeos.line_locate_point(line, point, normalized=normalized))
+        return {"success": True, "distance": distance, "normalized": normalized}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Coordinate Operations ====================
+
+@mcp.tool()
+def get_coordinates(wkt: str) -> dict:
+    """Extract coordinates from a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: Array of coordinates
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        coords = pygeos.get_coordinates(geom).tolist()
+        return {"success": True, "coordinates": coords, "num_coordinates": len(coords)}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_num_coordinates(wkt: str) -> dict:
+    """Get the number of coordinates in a geometry.
+    
+    Args:
+        wkt: WKT of the geometry
+    
+    Returns:
+        dict: Number of coordinates
+    """
+    try:
+        geom = pygeos.from_wkt(wkt)
+        num = int(pygeos.get_num_coordinates(geom))
+        return {"success": True, "num_coordinates": num}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Utility ====================
+
+@mcp.tool()
+def get_pygeos_version() -> dict:
+    """Get the PyGEOS library version.
+    
+    Returns:
+        dict: Version information
     """
     try:
-        from pygeos import from_wkt
-        geometry = from_wkt(wkt)
         return {
             "success": True,
-            "geometry": str(geometry)
+            "pygeos_version": pygeos.__version__,
+            "geos_version": pygeos.geos_version_string
         }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "error": str(e)}
+
+
+def create_app() -> FastMCP:
+    """Create and return the FastMCP application instance.
+    
+    Returns:
+        FastMCP: The application instance
+    """
+    return mcp