togo 0.1.0__tar.gz

togo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Giorgio Salluzzo
+
+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.

togo-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+include togo.pyx
+include tg.c
+include tg.h

togo-0.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: togo
+Version: 0.1.0
+Summary: Lightweight Python bindings for the TG geometry library
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# ToGo
+ToGo - Python bindings for TG
+(Geometry library for C - Fast point-in-polygon)
+
+# How ToGo Works
+
+Togo is a high-performance Python library for computational geometry, providing a Cython wrapper around the [tg](https://github.com/tidwall/tg) C library.
+
+## 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()
+```
+
+### Point, Line, Ring, Poly
+
+Building blocks for constructing geometries:
+
+```python
+# Create a point
+p = Point(1.0, 2.0)
+
+# Create a line
+line = Line([(0,0), (1,1), (2,2)])
+
+# Create a ring (closed line)
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+
+# Create a polygon with holes
+exterior = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+hole = Ring([(2,2), (8,2), (8,8), (2,8), (2,2)])
+poly = Poly(exterior, [hole])
+```
+
+### MultiGeometries
+
+Creating collections of geometries:
+
+```python
+# 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.0/README.md

@@ -0,0 +1,126 @@
+# ToGo
+ToGo - Python bindings for TG
+(Geometry library for C - Fast point-in-polygon)
+
+# How ToGo Works
+
+Togo is a high-performance Python library for computational geometry, providing a Cython wrapper around the [tg](https://github.com/tidwall/tg) C library.
+
+## 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()
+```
+
+### Point, Line, Ring, Poly
+
+Building blocks for constructing geometries:
+
+```python
+# Create a point
+p = Point(1.0, 2.0)
+
+# Create a line
+line = Line([(0,0), (1,1), (2,2)])
+
+# Create a ring (closed line)
+ring = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+
+# Create a polygon with holes
+exterior = Ring([(0,0), (10,0), (10,10), (0,10), (0,0)])
+hole = Ring([(2,2), (8,2), (8,8), (2,8), (2,2)])
+poly = Poly(exterior, [hole])
+```
+
+### MultiGeometries
+
+Creating collections of geometries:
+
+```python
+# 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.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = [
+  "setuptools>=61",
+  "wheel",
+  "Cython>=3.0.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+addopts = "-v -x -q"
+testpaths = ["tests"]
+pythonpath = ["."]

togo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

togo-0.1.0/setup.py

@@ -0,0 +1,47 @@
+import os
+import urllib.request
+from urllib.parse import urlparse
+
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+
+TG_SOURCE_URL = "https://raw.githubusercontent.com/tidwall/tg/main/tg.c"
+TG_SOURCE_FILENAME = os.path.basename(urlparse(TG_SOURCE_URL).path)
+
+if not os.path.exists(TG_SOURCE_FILENAME):
+    urllib.request.urlretrieve(TG_SOURCE_URL, TG_SOURCE_FILENAME)
+
+TG_HEADER_URL = "https://raw.githubusercontent.com/tidwall/tg/main/tg.h"
+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()
+
+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=["."],
+            )
+        ]
+    ),
+    python_requires=">=3.8",
+)

togo-0.1.0/tests/test_factories.py

@@ -0,0 +1,60 @@
+from togo import Geometry, Point, Line, Ring, Poly
+
+
+def test_multipoint_from_tuples():
+    pts = [(0, 0), (1, 2), (2, -1)]
+    mp1 = Geometry.from_multipoint(pts)
+    assert mp1.type_string() == "MultiPoint"
+    assert mp1.rect() == ((0.0, -1.0), (2.0, 2.0))
+
+
+def test_multipoint_from_points():
+    pts_obj = [Point(3, 3), Point(4, 5)]
+    mp2 = Geometry.from_multipoint(pts_obj)
+    assert mp2.type_string() == "MultiPoint"
+    assert mp2.rect() == ((3.0, 3.0), (4.0, 5.0))
+
+
+def test_multilinestring_from_coords():
+    ml1 = Geometry.from_multilinestring(
+        [
+            [(0, 0), (1, 1)],
+            [(2, 2), (3, 3), (4, 3)],
+        ]
+    )
+    assert ml1.type_string() == "MultiLineString"
+    assert ml1.num_lines() == 2
+    assert ml1.rect() == ((0.0, 0.0), (4.0, 3.0))
+
+
+def test_multilinestring_from_lines():
+    l1 = Line([(10, 10), (11, 12)])
+    l2 = Line([(9, 8), (10, 7)])
+    ml2 = Geometry.from_multilinestring([l1, l2])
+    assert ml2.type_string() == "MultiLineString"
+    assert ml2.num_lines() == 2
+
+
+def test_multipolygon_from_polys():
+    outer1 = Ring([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])
+    poly1 = Poly(outer1)
+    outer2 = Ring([(2, 2), (3, 2), (3, 3), (2, 3), (2, 2)])
+    poly2 = Poly(outer2)
+    mp = Geometry.from_multipolygon([poly1, poly2])
+    assert mp.type_string() == "MultiPolygon"
+    assert mp.num_polys() == 2
+    assert mp.rect() == ((0.0, 0.0), (3.0, 3.0))
+
+
+def test_geometrycollection_mixed_inputs():
+    point = Point(1, 2)
+    line = Line([(0, 0), (1, 1)])
+    ring = Ring([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])
+    poly = Poly(ring)
+    geom_point = point.as_geometry()
+
+    gc = Geometry.from_geometrycollection(
+        [geom_point, line, ring, poly, (5, 6), Point(7, 8)]
+    )
+    assert gc.type_string() == "GeometryCollection"
+    assert gc.num_geometries() == 6

togo-0.1.0/tests/test_geometries.py

@@ -0,0 +1,60 @@
+from togo import Geometry, Rect, Point
+
+from tests.geometries import TOGO, BENIN, GRAN_BUENOS_AIRES_AREA
+
+
+def test_togo():
+    togo = Geometry(TOGO)
+    assert togo.memsize() == 6080
+    assert not togo.is_empty()
+    assert not togo.has_z()
+    assert togo.dims() == 2
+    assert togo.type_string() == "Polygon"
+    bbox = togo.rect()
+    assert bbox == ((-0.149762, 6.100546), (1.799327, 11.13854))
+    min_, max_ = Point(*bbox[0]), Point(*bbox[1])
+    rect = Rect(min_, max_)
+    assert rect.min.as_tuple() == bbox[0]
+    assert rect.max.as_tuple() == bbox[1]
+    togo_center = rect.center()
+    assert togo_center.as_tuple() == (0.8247825, 8.619543)
+    assert togo.intersects(togo_center.as_geometry())
+
+
+def test_benin():
+    benin = Geometry(BENIN, fmt="geojson")
+    assert benin.memsize() == 6688
+    assert not benin.is_empty()
+    assert not benin.has_z()
+    assert benin.dims() == 2
+    assert benin.type_string() == "Polygon"
+    bbox = benin.rect()
+    assert bbox == ((0.776667, 6.218721), (3.855, 12.396658))
+    min_, max_ = Point(*bbox[0]), Point(*bbox[1])
+    rect = Rect(min_, max_)
+    assert rect.min.as_tuple() == bbox[0]
+    assert rect.max.as_tuple() == bbox[1]
+    benin_center = rect.center()
+    assert benin_center.as_tuple() == (2.3158335, 9.3076895)
+    assert benin.intersects(benin_center.as_geometry())
+
+
+def test_buenos_aires():
+    b_aires = Geometry(GRAN_BUENOS_AIRES_AREA, fmt="wkt")
+    assert b_aires.memsize() == 456
+    assert not b_aires.is_empty()
+    assert b_aires.has_z()
+    assert b_aires.dims() == 3
+    assert b_aires.type_string() == "Polygon"
+    bbox = b_aires.rect()
+    assert bbox == (
+        (-59.01433270595447, -35.07421568123671),
+        (-57.75103350378777, -34.33189712265184),
+    )
+    min_, max_ = Point(*bbox[0]), Point(*bbox[1])
+    rect = Rect(min_, max_)
+    assert rect.min.as_tuple() == bbox[0]
+    assert rect.max.as_tuple() == bbox[1]
+    b_aires_center = rect.center()
+    assert b_aires_center.as_tuple() == (-58.38268310487112, -34.70305640194427)
+    assert b_aires.intersects(b_aires_center.as_geometry())

togo-0.1.0/tests/test_geometry.py

@@ -0,0 +1,158 @@
+import pytest
+from togo import Geometry
+
+
+def test_geometry_wkt():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    assert g.type_string() == "Point"
+    assert g.rect() == ((1.0, 2.0), (1.0, 2.0))
+    assert g.memsize() == 24
+    assert g.num_points() == 0  # FIXME? Points in a Point geometry is considered 0
+    assert not g.is_feature()
+    assert not g.is_featurecollection()
+    assert not g.is_empty()
+    assert g.dims() == 2
+    assert g.has_z() is False
+    assert g.has_m() is False
+    assert g.to_wkt() == "POINT(1 2)"
+
+
+def test_geometry_equals():
+    g1 = Geometry("POINT(1 2)", fmt="wkt")
+    g2 = Geometry("POINT(1 2)", fmt="wkt")
+    g3 = Geometry("POINT(2 3)", fmt="wkt")
+    assert g1.equals(g2)
+    assert not g1.equals(g3)
+
+
+def test_geometry_disjoint():
+    g1 = Geometry("POINT(1 2)", fmt="wkt")
+    g2 = Geometry("POINT(2 3)", fmt="wkt")
+    assert g1.disjoint(g2)
+
+
+def test_geometry_contains():
+    g1 = Geometry("POINT(1 2)", fmt="wkt")
+    g2 = Geometry("POINT(1 2)", fmt="wkt")
+    assert g1.contains(g2)
+
+
+def test_geometry_to_geojson():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    geojson = g.to_geojson()
+    assert geojson == '{"type":"Point","coordinates":[1,2]}'
+
+
+def test_geometry_to_hex():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    hexstr = g.to_hex()
+    assert hexstr == "0101000000000000000000F03F0000000000000040"
+
+
+def test_geometry_to_wkb():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    wkb = g.to_wkb()
+    assert (
+        wkb
+        == b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@"
+    )
+
+
+def test_geometry_to_geobin():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    geobin = g.to_geobin()
+    assert (
+        geobin
+        == b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@"
+    )
+
+
+def test_geometry_intersects():
+    g1 = Geometry("POLYGON((10 10,20 10,20 20,10 20,10 10))", fmt="wkt")
+    g2 = Geometry("POINT(15 15)", fmt="wkt")
+    g3 = Geometry("POINT(23 24)", fmt="wkt")
+    assert g1.intersects(g2)
+    assert not g1.intersects(g3)
+
+
+def test_equals():
+    g1 = Geometry("POINT(1 2)", fmt="wkt")
+    g2 = Geometry('{"type":"Point","coordinates":[1,2]}', fmt="geojson")
+    g3 = Geometry("POINT(2 3)", fmt="wkt")
+    assert g1.equals(g2)
+    assert not g1.equals(g3)
+
+
+def test_geometry_num_lines_polys_geometries():
+    g_lines = Geometry("MULTILINESTRING((0 0,1 1),(2 2,3 3))", fmt="wkt")
+    assert g_lines.num_lines() == 2
+    g_polys = Geometry(
+        "MULTIPOLYGON(((0 0,1 0,1 1,0 1,0 0)),((2 2,3 2,3 3,2 3,2 2)))", fmt="wkt"
+    )
+    assert g_polys.num_polys() == 2
+    g_collection = Geometry(
+        "GEOMETRYCOLLECTION(POINT(1 2),LINESTRING(0 0,1 1))", fmt="wkt"
+    )
+    assert g_collection.num_geometries() == 2
+
+
+def test_geometry_z_m():
+    g = Geometry("POINT ZM (1 2 3 4)", fmt="wkt")
+    assert g.has_z() is True
+    assert g.has_m() is True
+    assert g.z() == 3.0
+    assert g.m() == 4.0
+
+
+def test_geometry_spatial_predicates():
+    g1 = Geometry("POLYGON((0 0,2 0,2 2,0 2,0 0))", fmt="wkt")
+    g2 = Geometry("POINT(1 1)", fmt="wkt")
+    g3 = Geometry("POINT(3 3)", fmt="wkt")
+    assert g1.covers(g2)
+    assert g2.coveredby(g1)
+    assert not g1.covers(g3)
+    assert not g3.coveredby(g1)
+    assert g1.touches(Geometry("LINESTRING(0 0,2 0)", fmt="wkt"))
+    assert g1.intersects(g2)
+    assert not g1.intersects(g3)
+
+
+def test_geometry_to_wkb_and_geobin():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    wkb = g.to_wkb()
+    geobin = g.to_geobin()
+    assert isinstance(wkb, bytes)
+    assert isinstance(geobin, bytes)
+    assert len(wkb) > 0
+    assert len(geobin) > 0
+
+
+def test_geometry_constructor_wkt():
+    g = Geometry("POINT(1 2)", fmt="wkt")
+    assert g.type_string() == "Point"
+    assert g.rect() == ((1.0, 2.0), (1.0, 2.0))
+
+
+def test_geometry_constructor_geojson():
+    geojson = '{"type":"Point","coordinates":[1,2]}'
+    g = Geometry(geojson, fmt="geojson")
+    assert g.type_string() == "Point"
+    assert g.rect() == ((1.0, 2.0), (1.0, 2.0))
+
+
+def test_geometry_constructor_hex():
+    hexstr = "0101000000000000000000F03F0000000000000040"
+    g = Geometry(hexstr, fmt="hex")
+    assert g.type_string() == "Point"
+    assert g.rect() == ((1.0, 2.0), (1.0, 2.0))
+
+
+def test_geometry_constructor_invalid():
+    # Note: The Geometry constructor only supports 'wkt', 'geojson', and 'hex' formats.
+    # 'wkb' is not a supported input format for the constructor.
+    with pytest.raises(ValueError):
+        Geometry("not a geometry", fmt="wkt")
+    with pytest.raises(ValueError):
+        Geometry("not a geometry", fmt="geojson")
+    with pytest.raises(ValueError):
+        Geometry("not a geometry", fmt="hex")

togo-0.1.0/tests/test_line.py

@@ -0,0 +1,50 @@
+import pytest
+from togo import Line, Rect, Geometry
+
+
+def test_line_basic():
+    points = [(0, 0), (1, 1), (2, 2)]
+    line = Line(points)
+    assert line.num_points() == 3
+    assert line.points() == points
+    assert isinstance(line.length(), float)
+    rect = line.rect()
+    assert isinstance(rect, Rect)
+    assert rect.min.as_tuple() == (0, 0)
+    assert rect.max.as_tuple() == (2, 2)
+    assert line.is_clockwise() in (True, False)
+
+
+def test_line_two_points():
+    points = [(0, 0), (1, 0)]
+    line = Line(points)
+    assert line.num_points() == 2
+    assert line.points() == points
+    assert line.length() == pytest.approx(1.0)
+
+
+def test_line_collinear():
+    points = [(0, 0), (1, 1), (2, 2)]
+    line = Line(points)
+    # Length should be sqrt(2) + sqrt(2)
+    expected_length = 2**0.5 + 2**0.5
+    assert line.length() == pytest.approx(expected_length)
+
+
+def test_line_closed():
+    points = [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]
+    line = Line(points)
+    assert line.num_points() == 5
+    assert line.points() == points
+    # Perimeter of a square
+    assert line.length() == pytest.approx(4.0)
+
+
+def test_line_as_geometry():
+    points = [(0, 0), (1, 1), (2, 2)]
+    line = Line(points)
+    g = line.as_geometry()
+    assert isinstance(g, Geometry)
+    assert g.type_string() == "LineString"
+    rect = g.rect()
+    assert rect == ((0.0, 0.0), (2.0, 2.0))