[feat] massive API expansion: predicates, accessors, LinearRing

Add 140+ methods across Point/LineString/Polygon/LinearRing:
- All DE-9IM predicates: contains, within, crosses, disjoint, overlaps,
  touches, covers, covered_by, equals, equals_exact, relates
- Accessors: wkt, wkb_hex, type, geom_type, has_z, bounds, area, length
- Properties: is_empty, is_simple, is_valid, is_closed, is_ring, is_ccw
- Geometry: centroid, normalize, coords, xy, exterior, interiors
- Distance metrics: hausdorff_distance
- New LinearRing class with full shapely-compatible API

Architecture:
- shapely/detail/geos_utils.h: shared GEOS utility functions
- Template-based cross-type predicates via friend declarations
- pybind11 bindings for all new methods with systematic naming
- 41 new comprehensive coupled C++ vs Python tests (142 total)

Also includes CI fix: install shapely via pip for version detection

Author: peng.li24

example/main.cpp

@@ -1,21 +1,59 @@
-// C++ 特有文件，Python 端无直接对应。
-// shapelycpp pure native C++ 使用示例 (zero pybind11 dependency).
+// shapelycpp pure native C++ usage example (zero pybind11 dependency)
 
 #include <iostream>
 #include "shapely/geometry/point.h"
 #include "shapely/geometry/linestring.h"
+#include "shapely/geometry/polygon.h"
+#include "shapely/geometry/linearring.h"
+
+using namespace shapely::geometry;
 
 int main() {
-    // Point operations
-    shapely::geometry::Point<double> p1(0.0, 0.0);
-    shapely::geometry::Point<double> p2(3.0, 4.0);
+    // -- Point --
+    Point<double> p1(0.0, 0.0), p2(3.0, 4.0);
+    std::cout << "Point distance: " << p1.distance(p2) << " (expected 5.0)" << std::endl;
+    std::cout << "Point WKT: " << p1.wkt() << std::endl;
+    std::cout << "Point is_valid: " << p1.is_valid() << std::endl;
+    std::cout << "Point bounds: [" << p1.bounds()[0] << ", " << p1.bounds()[1]
+              << ", " << p1.bounds()[2] << ", " << p1.bounds()[3] << "]" << std::endl;
+
+    // -- Buffer --
+    auto buf = p1.buffer(10.0);
+    std::cout << "Buffer area: " << buf.area() << std::endl;
+    std::cout << "Buffer WKT: " << buf.wkt() << std::endl;
+
+    // -- Predicates --
+    double sq_coords[] = {0,0, 10,0, 10,10, 0,10};
+    Polygon<double> sq(sq_coords, 4, 2);
+    Point<double> inside(5, 5), outside(20, 20);
+    std::cout << "Square contains inside point: " << sq.contains(inside) << " (expected 1)" << std::endl;
+    std::cout << "Square contains outside point: " << sq.contains(outside) << " (expected 0)" << std::endl;
+    std::cout << "Square disjoint outside point: " << sq.disjoint(outside) << " (expected 1)" << std::endl;
+
+    // -- LineString --
+    double ls_coords[] = {0,0, 10,0};
+    LineString<double> ls(ls_coords, 2);
+    std::cout << "LineString length: " << ls.length() << " (expected 10.0)" << std::endl;
+    std::cout << "LineString is_closed: " << ls.is_closed() << " (expected 0)" << std::endl;
+    std::cout << "LineString WKT: " << ls.wkt() << std::endl;
+
+    // -- intersects --
+    double tri_coords[] = {5,-5, 15,0, 5,5};
+    Polygon<double> tri(tri_coords, 3, 2);
+    std::cout << "LineString intersects triangle: " << ls.intersects(tri) << " (expected 1)" << std::endl;
 
-    double d = p1.distance(p2);
-    std::cout << "Distance: " << d << " (expected 5.0)" << std::endl;
+    // -- LinearRing --
+    double ring_coords[] = {0,0, 10,0, 10,10, 0,10};
+    LinearRing<double> ring(ring_coords, 4);
+    std::cout << "LinearRing is_closed: " << ring.is_closed() << " (expected 1)" << std::endl;
+    std::cout << "LinearRing is_ccw: " << ring.is_ccw() << std::endl;
+    std::cout << "LinearRing length: " << ring.length() << std::endl;
+    std::cout << "LinearRing WKT: " << ring.wkt() << std::endl;
 
-    // Buffer
-    auto buffered = p1.buffer(10.0);
-    std::cout << "Buffer created OK" << std::endl;
+    // -- Polygon exterior --
+    auto exterior = sq.exterior();
+    std::cout << "Polygon exterior rows: " << exterior.rows() << " (expected 5)" << std::endl;
 
+    std::cout << "\nAll examples passed!" << std::endl;
     return 0;
 }

shapely/detail/geos_utils.h

@@ -0,0 +1,147 @@
+// Internal GEOS utility functions shared across geometry types.
+// NOT part of public API — do not include directly.
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/Polygon.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Envelope.h>
+#include <geos/io/WKTWriter.h>
+#include <geos/io/WKBWriter.h>
+#include <geos/algorithm/distance/DiscreteHausdorffDistance.h>
+#include <geos/simplify/TopologyPreservingSimplifier.h>
+#include <geos/operation/valid/IsValidOp.h>
+
+namespace shapely {
+namespace detail {
+
+// --- WKT / WKB serialization ------------------------------------------------
+
+inline std::string geos_to_wkt(const geos::geom::Geometry* g) {
+    if (!g || g->isEmpty()) return "GEOMETRYCOLLECTION EMPTY";
+    geos::io::WKTWriter writer;
+    return writer.write(g);
+}
+
+inline std::string geos_to_wkb_hex(const geos::geom::Geometry* g) {
+    if (!g || g->isEmpty()) return "";
+    geos::io::WKBWriter writer;
+    std::ostringstream oss;
+    writer.writeHEX(*g, oss);
+    return oss.str();
+}
+
+// --- Predicates -------------------------------------------------------------
+
+inline bool geos_contains(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->contains(b);
+}
+
+inline bool geos_within(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->within(b);
+}
+
+inline bool geos_crosses(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->crosses(b);
+}
+
+inline bool geos_disjoint(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return true;
+    return a->disjoint(b);
+}
+
+inline bool geos_overlaps(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->overlaps(b);
+}
+
+inline bool geos_touches(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->touches(b);
+}
+
+inline bool geos_covers(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->covers(b);
+}
+
+inline bool geos_covered_by(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return false;
+    return a->coveredBy(b);
+}
+
+inline bool geos_equals(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a && !b) return true;
+    if (!a || !b) return false;
+    return a->equals(b);
+}
+
+inline bool geos_equals_exact(const geos::geom::Geometry* a, const geos::geom::Geometry* b, double tol) {
+    if (!a && !b) return true;
+    if (!a || !b) return false;
+    return a->equalsExact(b, tol);
+}
+
+inline std::string geos_relate(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return "";
+    return a->relate(b)->toString();
+}
+
+inline bool geos_relate_pattern(const geos::geom::Geometry* a, const geos::geom::Geometry* b, const std::string& pat) {
+    if (!a || !b) return false;
+    return a->relate(b, pat);
+}
+
+// --- Geometry property helpers ----------------------------------------------
+
+inline std::string geos_geom_type(const geos::geom::Geometry* g) {
+    if (!g) return "GeometryCollection";
+    return g->getGeometryType();
+}
+
+inline bool geos_is_simple(const geos::geom::Geometry* g) {
+    return g && g->isSimple();
+}
+
+inline bool geos_is_valid(const geos::geom::Geometry* g) {
+    return g && g->isValid();
+}
+
+inline bool geos_is_empty(const geos::geom::Geometry* g) {
+    return !g || g->isEmpty();
+}
+
+inline int geos_has_z(const geos::geom::Geometry* g) {
+    return g ? (g->getCoordinateDimension() > 2) : 0;
+}
+
+inline double geos_area(const geos::geom::Geometry* g) {
+    return g ? g->getArea() : 0.0;
+}
+
+inline double geos_length(const geos::geom::Geometry* g) {
+    return g ? g->getLength() : 0.0;
+}
+
+inline double geos_hausdorff_distance(const geos::geom::Geometry* a, const geos::geom::Geometry* b) {
+    if (!a || !b) return 0.0;
+    return geos::algorithm::distance::DiscreteHausdorffDistance(*a, *b).distance();
+}
+
+inline std::vector<double> geos_bounds(const geos::geom::Geometry* g) {
+    if (!g || g->isEmpty()) return {0, 0, 0, 0};
+    const geos::geom::Envelope* env = g->getEnvelopeInternal();
+    return {env->getMinX(), env->getMinY(), env->getMaxX(), env->getMaxY()};
+}
+
+} // namespace detail
+} // namespace shapely