togo 0.1.0__tar.gz → 0.1.3__tar.gz

togo-0.1.3/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: togo
+Version: 0.1.3
+Summary: Lightweight Python bindings for the TG geometry library
+Author-email: Giorgio Salluzzo <giorgio.salluzzo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mindflayer/togo
+Project-URL: Source, https://github.com/mindflayer/togo
+Project-URL: Tracker, https://github.com/mindflayer/togo/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license
+Dynamic: license-file
+
+# ToGo
+Python bindings for [TG](https://github.com/tidwall/tg)
+(Geometry library for C - Fast point-in-polygon)
+
+ToGo is a high-performance Python library for computational geometry, providing a Cython wrapper around the above-mentioned C library.
+
+The main goal is to offer a Pythonic, object-oriented, fast and memory-efficient library for geometric operations, including spatial predicates, format conversions, and spatial indexing.
+
+While ToGo's API interfaces are still a work in progress, the underling C library is stable and well-tested.
+
+## Installation
+
+```bash
+pip install togo
+```
+
+## Features
+
+- Fast and efficient geometric operations
+- Support for standard geometry types: Point, Line, Ring, Polygon, and their multi-variants
+- Geometric predicates: contains, intersects, covers, touches, etc.
+- Format conversion between WKT, GeoJSON, WKB, and HEX
+- Spatial indexing for accelerated queries
+- Memory-efficient C implementation with Python-friendly interface
+
+## Basic Usage
+
+```python
+from togo import Geometry, Point, Ring, Poly
+
+# Create a geometry from GeoJSON
+geom = Geometry('{"type":"Point","coordinates":[1.0,2.0]}')
+
+# Create a point
+point = Point(1.0, 2.0)
+
+# Create a polygon
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+polygon = Poly(ring)
+
+# Convert to various formats
+wkt = polygon.as_geometry().to_wkt()
+geojson = polygon.as_geometry().to_geojson()
+
+# Perform spatial predicates
+point_geom = point.as_geometry()
+contains = polygon.as_geometry().contains(point_geom)
+```
+
+## Core Classes
+
+### Geometry
+
+The base class that wraps tg_geom structures and provides core operations:
+
+```python
+# Create from various formats
+g1 = Geometry('POINT(1 2)', fmt='wkt')
+g2 = Geometry('{"type":"Point","coordinates":[1,2]}', fmt='geojson')
+
+# Geometric predicates
+g1.intersects(g2)
+g1.contains(g2)
+g1.within(g2)
+
+# Format conversion
+g1.to_wkt()
+g1.to_geojson()
+
+# Access sub-geometries by index (e.g., for GeometryCollection, MultiPoint, etc.)
+gc = Geometry('GEOMETRYCOLLECTION(POINT(1 2),POINT(3 4))', fmt='wkt')
+first = gc[0]  # Bound to TG function call tg_geom_geometry_at(idx)
+second = gc[1]
+print(first.type_string())  # 'Point'
+```
+
+### Point
+
+```python
+from togo import Point
+
+# Create a point
+p = Point(1.0, 2.0)
+
+# Access coordinates
+print(f"X: {p.x}, Y: {p.y}")
+
+# Get as a tuple
+print(p.as_tuple())
+
+# Convert to a Geometry object
+geom = p.as_geometry()
+print(geom.type_string())
+```
+
+### Segment
+
+```python
+from togo import Segment, Point
+
+# Create a segment from two points (or tuples)
+seg = Segment(Point(0, 0), Point(1, 1))
+# Or using tuples
+tuple_seg = Segment((0, 0), (1, 1))
+
+# Access endpoints
+print(seg.a)  # Point(0, 0)
+print(seg.b)  # Point(1, 1)
+
+# Get the bounding rectangle
+rect = seg.rect()
+print(rect)  # ((0.0, 0.0), (1.0, 1.0))
+
+# Check intersection with another segment
+other = Segment((1, 1), (2, 2))
+print(seg.intersects(other))  # True or False
+```
+
+### Line
+
+```python
+from togo import Line
+
+# Create a line from a list of tuples
+line = Line([(0,0), (1,1), (2,0)])
+
+# Get number of points
+print(f"Number of points: {line.num_points()}")
+
+# Get all points as a list of tuples
+print(f"Points: {line.points()}")
+
+# Get the length of the line
+print(f"Length: {line.length()}")
+
+# Get the bounding box
+print(f"Bounding box: {line.rect()}")
+
+# Get a point by index
+print(f"First point: {line[0].as_tuple()}")
+```
+
+### Ring
+
+```python
+from togo import Ring
+
+# Create a ring (must be closed)
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+
+# Get area and perimeter
+print(f"Area: {ring.area()}")
+print(f"Perimeter: {ring.perimeter()}")
+
+# Check if it's convex or clockwise
+print(f"Is convex: {ring.is_convex()}")
+print(f"Is clockwise: {ring.is_clockwise()}")
+
+# Get bounding box
+min_pt, max_pt = ring.rect().min, ring.rect().max
+print(f"Bounding box: {min_pt.as_tuple()}, {max_pt.as_tuple()}")
+```
+
+### Poly
+
+```python
+from togo import Poly, Ring, Point
+
+# Create a polygon with one exterior ring and one interior hole
+exterior = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+hole1 = Ring([(1,1), (2,1), (2,2), (1,2), (1,1)])
+poly = Poly(exterior, holes=[hole1])
+
+# Get the exterior ring
+ext_ring = poly.exterior()
+print(f"Exterior has {ext_ring.num_points()} points")
+
+# Get number of holes
+print(f"Number of holes: {poly.num_holes()}")
+
+# Get a hole by index
+h = poly.hole(0)
+print(f"Hole area: {h.area()}")
+
+# A polygon is a geometry, so you can use geometry methods
+geom = poly.as_geometry()
+print(f"Contains point (5,5): {geom.contains(Point(5,5).as_geometry())}")
+# Point is inside the hole, so it is not contained by the polygon
+print(f"Contains point (1.5,1.5): {geom.contains(Point(1.5,1.5).as_geometry())}")
+```
+
+### MultiGeometries
+
+Creating collections of geometries:
+
+```python
+from togo import Geometry, Point, Line, Poly, Ring
+
+# Create a MultiPoint
+multi_point = Geometry.from_multipoint([(0,0), (1,1), Point(2,2)])
+
+# Create a MultiLineString
+multi_line = Geometry.from_multilinestring([
+    [(0,0), (1,1)],
+    Line([(2,2), (3,3)])
+])
+
+# Create a MultiPolygon
+poly1 = Poly(Ring([(0,0), (1,0), (1,1), (0,1), (0,0)]))
+poly2 = Poly(Ring([(2,2), (3,2), (3,3), (2,3), (2,2)]))
+multi_poly = Geometry.from_multipolygon([poly1, poly2])
+```
+
+## Polygon Indexing
+
+Togo supports different polygon indexing strategies for optimized spatial operations:
+
+```python
+from togo import TGIndex, set_polygon_indexing_mode
+
+# Set the indexing mode
+set_polygon_indexing_mode(TGIndex.NATURAL)  # or NONE, YSTRIPES
+```
+
+## Performance Considerations
+
+- Togo is optimized for speed and memory efficiency
+- For large datasets, proper indexing can significantly improve performance
+- Creating geometries with the appropriate format avoids unnecessary conversions
+
+Soon there will be a full API documentation, for now please refer to the test suite for more usage examples.

togo-0.1.3/README.md

@@ -0,0 +1,231 @@
+# ToGo
+Python bindings for [TG](https://github.com/tidwall/tg)
+(Geometry library for C - Fast point-in-polygon)
+
+ToGo is a high-performance Python library for computational geometry, providing a Cython wrapper around the above-mentioned C library.
+
+The main goal is to offer a Pythonic, object-oriented, fast and memory-efficient library for geometric operations, including spatial predicates, format conversions, and spatial indexing.
+
+While ToGo's API interfaces are still a work in progress, the underling C library is stable and well-tested.
+
+## Installation
+
+```bash
+pip install togo
+```
+
+## Features
+
+- Fast and efficient geometric operations
+- Support for standard geometry types: Point, Line, Ring, Polygon, and their multi-variants
+- Geometric predicates: contains, intersects, covers, touches, etc.
+- Format conversion between WKT, GeoJSON, WKB, and HEX
+- Spatial indexing for accelerated queries
+- Memory-efficient C implementation with Python-friendly interface
+
+## Basic Usage
+
+```python
+from togo import Geometry, Point, Ring, Poly
+
+# Create a geometry from GeoJSON
+geom = Geometry('{"type":"Point","coordinates":[1.0,2.0]}')
+
+# Create a point
+point = Point(1.0, 2.0)
+
+# Create a polygon
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+polygon = Poly(ring)
+
+# Convert to various formats
+wkt = polygon.as_geometry().to_wkt()
+geojson = polygon.as_geometry().to_geojson()
+
+# Perform spatial predicates
+point_geom = point.as_geometry()
+contains = polygon.as_geometry().contains(point_geom)
+```
+
+## Core Classes
+
+### Geometry
+
+The base class that wraps tg_geom structures and provides core operations:
+
+```python
+# Create from various formats
+g1 = Geometry('POINT(1 2)', fmt='wkt')
+g2 = Geometry('{"type":"Point","coordinates":[1,2]}', fmt='geojson')
+
+# Geometric predicates
+g1.intersects(g2)
+g1.contains(g2)
+g1.within(g2)
+
+# Format conversion
+g1.to_wkt()
+g1.to_geojson()
+
+# Access sub-geometries by index (e.g., for GeometryCollection, MultiPoint, etc.)
+gc = Geometry('GEOMETRYCOLLECTION(POINT(1 2),POINT(3 4))', fmt='wkt')
+first = gc[0]  # Bound to TG function call tg_geom_geometry_at(idx)
+second = gc[1]
+print(first.type_string())  # 'Point'
+```
+
+### Point
+
+```python
+from togo import Point
+
+# Create a point
+p = Point(1.0, 2.0)
+
+# Access coordinates
+print(f"X: {p.x}, Y: {p.y}")
+
+# Get as a tuple
+print(p.as_tuple())
+
+# Convert to a Geometry object
+geom = p.as_geometry()
+print(geom.type_string())
+```
+
+### Segment
+
+```python
+from togo import Segment, Point
+
+# Create a segment from two points (or tuples)
+seg = Segment(Point(0, 0), Point(1, 1))
+# Or using tuples
+tuple_seg = Segment((0, 0), (1, 1))
+
+# Access endpoints
+print(seg.a)  # Point(0, 0)
+print(seg.b)  # Point(1, 1)
+
+# Get the bounding rectangle
+rect = seg.rect()
+print(rect)  # ((0.0, 0.0), (1.0, 1.0))
+
+# Check intersection with another segment
+other = Segment((1, 1), (2, 2))
+print(seg.intersects(other))  # True or False
+```
+
+### Line
+
+```python
+from togo import Line
+
+# Create a line from a list of tuples
+line = Line([(0,0), (1,1), (2,0)])
+
+# Get number of points
+print(f"Number of points: {line.num_points()}")
+
+# Get all points as a list of tuples
+print(f"Points: {line.points()}")
+
+# Get the length of the line
+print(f"Length: {line.length()}")
+
+# Get the bounding box
+print(f"Bounding box: {line.rect()}")
+
+# Get a point by index
+print(f"First point: {line[0].as_tuple()}")
+```
+
+### Ring
+
+```python
+from togo import Ring
+
+# Create a ring (must be closed)
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+
+# Get area and perimeter
+print(f"Area: {ring.area()}")
+print(f"Perimeter: {ring.perimeter()}")
+
+# Check if it's convex or clockwise
+print(f"Is convex: {ring.is_convex()}")
+print(f"Is clockwise: {ring.is_clockwise()}")
+
+# Get bounding box
+min_pt, max_pt = ring.rect().min, ring.rect().max
+print(f"Bounding box: {min_pt.as_tuple()}, {max_pt.as_tuple()}")
+```
+
+### Poly
+
+```python
+from togo import Poly, Ring, Point
+
+# Create a polygon with one exterior ring and one interior hole
+exterior = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+hole1 = Ring([(1,1), (2,1), (2,2), (1,2), (1,1)])
+poly = Poly(exterior, holes=[hole1])
+
+# Get the exterior ring
+ext_ring = poly.exterior()
+print(f"Exterior has {ext_ring.num_points()} points")
+
+# Get number of holes
+print(f"Number of holes: {poly.num_holes()}")
+
+# Get a hole by index
+h = poly.hole(0)
+print(f"Hole area: {h.area()}")
+
+# A polygon is a geometry, so you can use geometry methods
+geom = poly.as_geometry()
+print(f"Contains point (5,5): {geom.contains(Point(5,5).as_geometry())}")
+# Point is inside the hole, so it is not contained by the polygon
+print(f"Contains point (1.5,1.5): {geom.contains(Point(1.5,1.5).as_geometry())}")
+```
+
+### MultiGeometries
+
+Creating collections of geometries:
+
+```python
+from togo import Geometry, Point, Line, Poly, Ring
+
+# Create a MultiPoint
+multi_point = Geometry.from_multipoint([(0,0), (1,1), Point(2,2)])
+
+# Create a MultiLineString
+multi_line = Geometry.from_multilinestring([
+    [(0,0), (1,1)],
+    Line([(2,2), (3,3)])
+])
+
+# Create a MultiPolygon
+poly1 = Poly(Ring([(0,0), (1,0), (1,1), (0,1), (0,0)]))
+poly2 = Poly(Ring([(2,2), (3,2), (3,3), (2,3), (2,2)]))
+multi_poly = Geometry.from_multipolygon([poly1, poly2])
+```
+
+## Polygon Indexing
+
+Togo supports different polygon indexing strategies for optimized spatial operations:
+
+```python
+from togo import TGIndex, set_polygon_indexing_mode
+
+# Set the indexing mode
+set_polygon_indexing_mode(TGIndex.NATURAL)  # or NONE, YSTRIPES
+```
+
+## Performance Considerations
+
+- Togo is optimized for speed and memory efficiency
+- For large datasets, proper indexing can significantly improve performance
+- Creating geometries with the appropriate format avoids unnecessary conversions
+
+Soon there will be a full API documentation, for now please refer to the test suite for more usage examples.

togo-0.1.3/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = [
+  "setuptools>=61",
+  "wheel",
+  "Cython>=3.0.0",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "togo"
+version = "0.1.3"
+description = "Lightweight Python bindings for the TG geometry library"
+readme = "README.md"
+authors = [
+  {name = "Giorgio Salluzzo", email = "giorgio.salluzzo@gmail.com"}
+]
+requires-python = ">=3.8"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: C",
+  "Operating System :: POSIX :: Linux",
+  "Intended Audience :: Developers",
+  "Topic :: Scientific/Engineering :: GIS"
+]
+dynamic = ["license"]
+
+[project.urls]
+Homepage = "https://github.com/mindflayer/togo"
+Source = "https://github.com/mindflayer/togo"
+Tracker = "https://github.com/mindflayer/togo/issues"
+
+[tool.pytest.ini_options]
+addopts = "-v -x -q"
+testpaths = ["tests"]
+pythonpath = ["."]

{togo-0.1.0 → togo-0.1.3}/setup.py

@@ -17,31 +17,36 @@ TG_HEADER_FILENAME = os.path.basename(urlparse(TG_HEADER_URL).path)
 if not os.path.exists(TG_HEADER_FILENAME):
     urllib.request.urlretrieve(TG_HEADER_URL, TG_HEADER_FILENAME)
 
-# Package metadata
-NAME = "togo"
-VERSION = "0.1.0"
-DESCRIPTION = "Lightweight Python bindings for the TG geometry library"
-LONG_DESCRIPTION = ""
-LONG_DESCRIPTION_CONTENT_TYPE = "text/markdown"
-if os.path.exists("README.md"):
-    with open("README.md", "r", encoding="utf-8") as f:
-        LONG_DESCRIPTION = f.read()
+# Enable optional AddressSanitizer build via env var ASAN=1
+asan_enabled = os.environ.get("ASAN") == "1"
+extra_compile_args = []
+extra_link_args = []
+if asan_enabled:
+    # Favor debuggability over speed
+    extra_compile_args += [
+        "-O1",
+        "-g",
+        "-fno-omit-frame-pointer",
+        "-fsanitize=address",
+    ]
+    extra_link_args += [
+        "-fsanitize=address",
+    ]
 
 setup(
-    name=NAME,
-    version=VERSION,
-    description=DESCRIPTION,
-    long_description=LONG_DESCRIPTION,
-    long_description_content_type=LONG_DESCRIPTION_CONTENT_TYPE,
-    license="MIT",
     ext_modules=cythonize(
         [
             Extension(
                 "togo",
                 sources=["togo.pyx", TG_SOURCE_FILENAME],
                 include_dirs=["."],
+                extra_compile_args=extra_compile_args,
+                extra_link_args=extra_link_args,
             )
         ]
     ),
-    python_requires=">=3.8",
+    # Explicitly disable auto-discovery in flat layout
+    packages=[],
+    py_modules=[],
+    license="MIT",
 )

{togo-0.1.0 → togo-0.1.3}/tests/test_geometry.py

@@ -94,6 +94,9 @@ def test_geometry_num_lines_polys_geometries():
         "GEOMETRYCOLLECTION(POINT(1 2),LINESTRING(0 0,1 1))", fmt="wkt"
     )
     assert g_collection.num_geometries() == 2
+    # Use Geometry.__getitem__ to access sub-geometries of MultiLineString
+    first_line = g_lines[0]
+    assert first_line.type_string() == "LineString"
 
 
 def test_geometry_z_m():
@@ -156,3 +159,37 @@ def test_geometry_constructor_invalid():
         Geometry("not a geometry", fmt="geojson")
     with pytest.raises(ValueError):
         Geometry("not a geometry", fmt="hex")
+
+
+def test_geometry_point_accessor():
+    g = Geometry("POINT(3 4)", fmt="wkt")
+    pt = g.point()
+    assert pt.x == 3.0 and pt.y == 4.0
+
+
+def test_geometry_line_accessor_and_from_linestring():
+    points = [(0, 0), (1, 1), (2, 2)]
+    g = Geometry.from_linestring(points)
+    line = g.line()
+    pts = line.points()
+    assert pts == points
+
+
+def test_geometry_poly_accessor():
+    # Polygon with one ring
+    wkt = "POLYGON((0 0,1 0,1 1,0 1,0 0))"
+    g = Geometry(wkt, fmt="wkt")
+    poly = g.poly()
+    ext = poly.exterior()
+    assert ext.num_points() == 5
+
+
+def test_geometry_geom_at():
+    # GeometryCollection with two points
+    g = Geometry("GEOMETRYCOLLECTION(POINT(1 2),POINT(3 4))", fmt="wkt")
+    g0 = g[0]
+    g1 = g[1]
+    assert g0.type_string() == "Point"
+    assert g1.type_string() == "Point"
+    assert g0.point().x == 1.0 and g0.point().y == 2.0
+    assert g1.point().x == 3.0 and g1.point().y == 4.0

{togo-0.1.0 → togo-0.1.3}/tests/test_line.py

@@ -48,3 +48,18 @@ def test_line_as_geometry():
     assert g.type_string() == "LineString"
     rect = g.rect()
     assert rect == ((0.0, 0.0), (2.0, 2.0))
+
+
+def test_line_getitem():
+    points = [(10, 20), (30, 40), (50, 60)]
+    line = Line(points)
+    pt0 = line[0]
+    pt1 = line[1]
+    pt2 = line[2]
+    assert pt0.x == 10 and pt0.y == 20
+    assert pt1.x == 30 and pt1.y == 40
+    assert pt2.x == 50 and pt2.y == 60
+    with pytest.raises(IndexError):
+        _ = line[3]
+    with pytest.raises(IndexError):
+        _ = line[-1]

togo-0.1.3/tests/test_segment.py

@@ -0,0 +1,17 @@
+from togo import Point, Segment
+
+
+def test_segment_creation_and_rect():
+    a = Point(0, 0)
+    b = Point(1, 1)
+    seg = Segment(a, b)
+    rect = seg.rect()
+    assert rect == ((0, 0), (1, 1))
+
+
+def test_segment_intersects():
+    seg1 = Segment(Point(0, 0), Point(1, 1))
+    seg2 = Segment(Point(0, 1), Point(1, 0))
+    seg3 = Segment(Point(2, 2), Point(3, 3))
+    assert seg1.intersects(seg2)
+    assert not seg1.intersects(seg3)