def __new__(self, *args): if len(args) == 0: # empty geometry # TODO better constructor return shapely.from_wkt("POINT EMPTY") elif len(args) > 3: raise TypeError( "Point() takes at most 3 arguments ({} given)".format( len(args))) elif len(args) == 1: coords = args[0] if isinstance(coords, Point): return coords # Accept either (x, y) or [(x, y)] if not hasattr(coords, "__getitem__"): # generators coords = list(coords) if isinstance(coords[0], tuple): coords = coords[0] geom = shapely.points(coords) else: # 2 or 3 args geom = shapely.points(*args) if not isinstance(geom, Point): raise ValueError("Invalid values passed to Point constructor") return geom
def test_dwithin(): p1 = shapely.points(50, 4) p2 = shapely.points(50.1, 4.1) actual = shapely.dwithin([p1, p2, None], p1, distance=0.05) np.testing.assert_equal(actual, [True, False, False]) assert actual.dtype == np.bool_ actual = shapely.dwithin([p1, p2, None], p1, distance=0.2) np.testing.assert_allclose(actual, [True, True, False]) assert actual.dtype == np.bool_ # an array of distances actual = shapely.dwithin(p1, p2, distance=[0.05, 0.2, np.nan]) np.testing.assert_allclose(actual, [False, True, False])
def setup(self): # create irregular polygons by merging overlapping point buffers self.left = shapely.union_all( shapely.buffer(shapely.points(np.random.random((500, 2)) * 500), 15)) # shift this up and right self.right = shapely.transform(self.left, lambda x: x + 50)
def test_from_wkb_hex(): # HEX form expected = shapely.points(1, 1) actual = shapely.from_wkb("0101000000000000000000F03F000000000000F03F") assert_geometries_equal(actual, expected) actual = shapely.from_wkb(b"0101000000000000000000F03F000000000000F03F") assert_geometries_equal(actual, expected)
def test_to_wkb_hex(): point = shapely.points(1, 1) actual = shapely.to_wkb(point, hex=True, byte_order=1) le = "01" point_type = "01000000" coord = "000000000000F03F" # 1.0 as double (LE) assert actual == le + point_type + 2 * coord
def test_from_wkt(): expected = shapely.points(1, 1) actual = shapely.from_wkt("POINT (1 1)") assert_geometries_equal(actual, expected) # also accept bytes actual = shapely.from_wkt(b"POINT (1 1)") assert_geometries_equal(actual, expected)
def test_to_wkb_3D(): point_z = shapely.points(1, 1, 1) actual = shapely.to_wkb(point_z, byte_order=1) # fmt: off assert actual == b"\x01\x01\x00\x00\x80\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?" # noqa # fmt: on actual = shapely.to_wkb(point_z, output_dimension=2, byte_order=1) assert actual == POINT11_WKB
def test_equals_exact_tolerance(): # specifying tolerance p1 = shapely.points(50, 4) p2 = shapely.points(50.1, 4.1) actual = shapely.equals_exact([p1, p2, None], p1, tolerance=0.05) np.testing.assert_allclose(actual, [True, False, False]) assert actual.dtype == np.bool_ actual = shapely.equals_exact([p1, p2, None], p1, tolerance=0.2) np.testing.assert_allclose(actual, [True, True, False]) assert actual.dtype == np.bool_ # default value for tolerance assert shapely.equals_exact(p1, p1).item() is True assert shapely.equals_exact(p1, p2).item() is False # an array of tolerances actual = shapely.equals_exact(p1, p2, tolerance=[0.05, 0.2, np.nan]) np.testing.assert_allclose(actual, [False, True, False])
def test_points_out(indices, expected): out = np.empty(4, dtype=object) out[2] = empty_point actual = shapely.points( [[2, 3], [2, 3]], indices=indices, out=out, ) assert_geometries_equal(out, expected) assert actual is out
def test_destroy_prepared(): arr = np.array([shapely.points(1, 1), None, shapely.box(0, 0, 1, 1)]) shapely.prepare(arr) assert arr[0]._ptr_prepared != 0 assert arr[2]._ptr_prepared != 0 shapely.destroy_prepared(arr) assert arr[0]._ptr_prepared == 0 assert arr[1] is None assert arr[2]._ptr_prepared == 0 shapely.destroy_prepared(arr) # does not error
def test_to_wkb_byte_order(): point = shapely.points(1.0, 1.0) be = b"\x00" le = b"\x01" point_type = b"\x01\x00\x00\x00" # 1 as 32-bit uint (LE) coord = b"\x00\x00\x00\x00\x00\x00\xf0?" # 1.0 as double (LE) assert shapely.to_wkb(point, byte_order=1) == le + point_type + 2 * coord assert (shapely.to_wkb(point, byte_order=0) == be + point_type[::-1] + 2 * coord[::-1])
def test_to_wkt(): point = shapely.points(1, 1) actual = shapely.to_wkt(point) assert actual == "POINT (1 1)" actual = shapely.to_wkt(point, trim=False) assert actual == "POINT (1.000000 1.000000)" actual = shapely.to_wkt(point, rounding_precision=3, trim=False) assert actual == "POINT (1.000 1.000)"
def _construct_points(x, y): x, y = np.asanyarray(x), np.asanyarray(y) if x.shape != y.shape: raise ValueError("X and Y shapes must be equivalent.") if x.dtype != np.float64: x = x.astype(np.float64) if y.dtype != np.float64: y = y.astype(np.float64) return shapely.points(x, y)
def setup(self): # create irregular polygons by merging overlapping point buffers self.polygon = shapely.union_all( shapely.buffer(shapely.points(np.random.random((1000, 2)) * 500), 10)) xmin = np.random.random(100) * 100 xmax = xmin + 100 ymin = np.random.random(100) * 100 ymax = ymin + 100 self.bounds = np.array([xmin, ymin, xmax, ymax]).T self.boxes = shapely.box(xmin, ymin, xmax, ymax)
def test_to_wkt_3D(): # 3D points point_z = shapely.points(1, 1, 1) actual = shapely.to_wkt(point_z) assert actual == "POINT Z (1 1 1)" actual = shapely.to_wkt(point_z, output_dimension=3) assert actual == "POINT Z (1 1 1)" actual = shapely.to_wkt(point_z, output_dimension=2) assert actual == "POINT (1 1)" actual = shapely.to_wkt(point_z, old_3d=True) assert actual == "POINT (1 1 1)"
def test_prepare(): arr = np.array([shapely.points(1, 1), None, shapely.box(0, 0, 1, 1)]) assert arr[0]._ptr_prepared == 0 assert arr[2]._ptr_prepared == 0 shapely.prepare(arr) assert arr[0]._ptr_prepared != 0 assert arr[1] is None assert arr[2]._ptr_prepared != 0 # preparing again actually does nothing original = arr[0]._ptr_prepared shapely.prepare(arr) assert arr[0]._ptr_prepared == original
def __new__(self, *args): """ Parameters ---------- There are 2 cases: 1) 1 parameter: this must satisfy the numpy array protocol. 2) 2 or more parameters: x, y, z : float Easting, northing, and elevation. """ if len(args) == 0: # empty geometry # TODO better constructor return shapely.from_wkt("POINT EMPTY") elif len(args) > 3: raise TypeError( "Point() takes at most 3 arguments ({} given)".format(len(args)) ) elif len(args) == 1: coords = args[0] if isinstance(coords, Point): return coords # Accept either (x, y) or [(x, y)] if not hasattr(coords, "__getitem__"): # generators coords = list(coords) if isinstance(coords[0], tuple): coords = coords[0] geom = shapely.points(coords) else: # 2 or 3 args geom = shapely.points(*args) if not isinstance(geom, Point): raise ValueError("Invalid values passed to Point constructor") return geom
def test_to_wkb_srid(): # hex representation of POINT (0 0) with SRID=4 ewkb = "01010000200400000000000000000000000000000000000000" wkb = "010100000000000000000000000000000000000000" actual = shapely.from_wkb(ewkb) assert shapely.to_wkt(actual, trim=True) == "POINT (0 0)" assert shapely.to_wkb(actual, hex=True, byte_order=1) == wkb assert shapely.to_wkb(actual, hex=True, include_srid=True, byte_order=1) == ewkb point = shapely.points(1, 1) point_with_srid = shapely.set_srid(point, np.int32(4326)) result = shapely.to_wkb(point_with_srid, include_srid=True, byte_order=1) assert np.frombuffer(result[5:9], "<u4").item() == 4326
def setup(self): # create irregular polygons my merging overlapping point buffers self.polygons = shapely.get_parts( shapely.union_all( shapely.buffer( shapely.points(np.random.random((2000, 2)) * 500), 5))) self.tree = shapely.STRtree(self.polygons) # initialize the tree by making a tiny query first self.tree.query(shapely.points(0, 0)) # create points that extend beyond the domain of the above polygons to ensure # some don't overlap self.points = shapely.points((np.random.random((2000, 2)) * 750) - 125) self.point_tree = shapely.STRtree( shapely.points(np.random.random((2000, 2)) * 750)) self.point_tree.query(shapely.points(0, 0)) # create points on a grid for testing equidistant nearest neighbors # creates 2025 points grid_coords = np.mgrid[:45, :45].T.reshape(-1, 2) self.grid_point_tree = shapely.STRtree(shapely.points(grid_coords)) self.grid_points = shapely.points(grid_coords + 0.5)
def setup(self): self.coords = np.random.random((10000, 2)) self.points = shapely.points(self.coords)
def test_to_wkb(): point = shapely.points(1, 1) actual = shapely.to_wkb(point, byte_order=1) assert actual == POINT11_WKB
def test_relate(): p1 = shapely.points(0, 0) p2 = shapely.points(1, 1) actual = shapely.relate(p1, p2) assert isinstance(actual, str) assert actual == "FF0FFF0F2"
def test_shared_paths_non_linestring(): g1 = shapely.linestrings([(0, 0), (1, 0), (1, 1)]) g2 = shapely.points(0, 1) with pytest.raises(shapely.GEOSException): shapely.shared_paths(g1, g2)
def test_from_wkb(): expected = shapely.points(1, 1) actual = shapely.from_wkb(POINT11_WKB) assert_geometries_equal(actual, expected)
def setup(self): self.points = shapely.points(np.random.random((100000, 2))) self.polygon = shapely.polygons(np.random.random((3, 2)))
def time_tree_create(self): tree = shapely.STRtree(self.polygons) tree.query(shapely.points(0, 0))
def test_line_locate_point_geom_array(): point = shapely.points(0, 1) actual = shapely.line_locate_point([line_string, linear_ring], point) np.testing.assert_allclose(actual, [0.0, 3.0])
import sys from contextlib import contextmanager import numpy as np import pytest import shapely shapely20_todo = pytest.mark.xfail( strict=False, reason="Not yet implemented for Shapely 2.0" ) point_polygon_testdata = ( shapely.points(np.arange(6), np.arange(6)), shapely.box(2, 2, 4, 4), ) point = shapely.points(2, 3) line_string = shapely.linestrings([(0, 0), (1, 0), (1, 1)]) linear_ring = shapely.linearrings([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]) polygon = shapely.polygons([(0, 0), (2, 0), (2, 2), (0, 2), (0, 0)]) multi_point = shapely.multipoints([(0, 0), (1, 2)]) multi_line_string = shapely.multilinestrings([[(0, 0), (1, 2)]]) multi_polygon = shapely.multipolygons( [ [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], [(2.1, 2.1), (2.2, 2.1), (2.2, 2.2), (2.1, 2.2), (2.1, 2.1)], ] ) geometry_collection = shapely.geometrycollections( [shapely.points(51, -1), shapely.linestrings([(52, -1), (49, 2)])] )
def test_line_locate_point_geom_array2(): points = shapely.points([[0, 0], [1, 0]]) actual = shapely.line_locate_point(line_string, points) np.testing.assert_allclose(actual, [0.0, 1.0])
[100.0, 0.0], ]], }, "properties": { "prop1": { "this": "that" }, "prop0": "value0" }, }, ], }, indent=4, ) GEOJSON_GEOMETRY_EXPECTED = shapely.points(125.6, 10.1) GEOJSON_COLLECTION_EXPECTED = [ shapely.points([102.0, 0.6]), shapely.linestrings([[102.0, 0.0], [103.0, 1.0], [104.0, 0.0], [105.0, 1.0]]), shapely.polygons([[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]), ] class ShapelyGeometryMock: def __init__(self, g): self.g = g self.__geom__ = g._ptr if hasattr(g, "_ptr") else g @property