Skip to content

spatial

This module provides classes and functions to help with light geospatial objects (projections, bounding boxes, etc).

BoundingBox

The bounding box class

Source code in scenes/spatial.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class BoundingBox:
    """
    The bounding box class
    """

    def __init__(self, xmin: float, ymin: float, xmax: float, ymax: float):
        """
        Args:
            xmin: Lower value on the x-axis
            ymin: Lower value on the y-axis
            xmax: Higher value on the x-axis
            ymax: Higher value on the y-axis
        """
        self.xmin = xmin
        self.ymin = ymin
        self.xmax = xmax
        self.ymax = ymax

    def union(self, other: BoundingBox) -> BoundingBox:
        """
        Return a new bounding box resulting in the union of self and other

        Args:
            other: another bounding box

        Returns:
            a new bounding box

        """
        return BoundingBox(xmin=min(self.xmin, other.xmin),
                           ymin=min(self.ymin, other.ymin),
                           xmax=max(self.xmax, other.xmax),
                           ymax=max(self.ymax, other.ymax))

    def __str__(self) -> str:
        """
        Returns a string representing the object

        Returns:
            str(self.to_list())

        """
        return str(self.to_list())

    def to_list(self) -> List[float]:
        """
        Converts the bbox into a list of coordinates, like rasterio does.

        Returns:
            [xmin, ymin, xmax, ymax]

        """
        return [self.xmin, self.ymin, self.xmax, self.ymax]

    def to_ogrgeom(self) -> ogr.Geometry:
        """
        Converts the BoundingBox into an OGR geometry

        Returns: an OGR Geometry from the bounding box

        """
        coords = ((self.xmin, self.ymin),
                  (self.xmax, self.ymin),
                  (self.xmax, self.ymax),
                  (self.xmin, self.ymax))
        return coords2poly(coords)

__init__(xmin, ymin, xmax, ymax)

Parameters:

Name Type Description Default
xmin float

Lower value on the x-axis

 required
ymin float

Lower value on the y-axis

 required
xmax float

Higher value on the x-axis

 required
ymax float

Higher value on the y-axis

 required
Source code in scenes/spatial.py 
37
38
39
40
41
42
43
44
45
46
47
48
def __init__(self, xmin: float, ymin: float, xmax: float, ymax: float):
    """
    Args:
        xmin: Lower value on the x-axis
        ymin: Lower value on the y-axis
        xmax: Higher value on the x-axis
        ymax: Higher value on the y-axis
    """
    self.xmin = xmin
    self.ymin = ymin
    self.xmax = xmax
    self.ymax = ymax

__str__()

Returns a string representing the object

Returns:

Type Description
str

str(self.to_list())
Source code in scenes/spatial.py 
66
67
68
69
70
71
72
73
74
def __str__(self) -> str:
    """
    Returns a string representing the object

    Returns:
        str(self.to_list())

    """
    return str(self.to_list())

to_list()

Converts the bbox into a list of coordinates, like rasterio does.

Returns:

Type Description
List[float]

[xmin, ymin, xmax, ymax]
Source code in scenes/spatial.py 
76
77
78
79
80
81
82
83
84
def to_list(self) -> List[float]:
    """
    Converts the bbox into a list of coordinates, like rasterio does.

    Returns:
        [xmin, ymin, xmax, ymax]

    """
    return [self.xmin, self.ymin, self.xmax, self.ymax]

to_ogrgeom()

Converts the BoundingBox into an OGR geometry

Returns: an OGR Geometry from the bounding box

Source code in scenes/spatial.py 
86
87
88
89
90
91
92
93
94
95
96
97
def to_ogrgeom(self) -> ogr.Geometry:
    """
    Converts the BoundingBox into an OGR geometry

    Returns: an OGR Geometry from the bounding box

    """
    coords = ((self.xmin, self.ymin),
              (self.xmax, self.ymin),
              (self.xmax, self.ymax),
              (self.xmin, self.ymax))
    return coords2poly(coords)

union(other)

Return a new bounding box resulting in the union of self and other

Parameters:

Name Type Description Default
other BoundingBox

another bounding box

 required

Returns:

Type Description
BoundingBox

a new bounding box
Source code in scenes/spatial.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
def union(self, other: BoundingBox) -> BoundingBox:
    """
    Return a new bounding box resulting in the union of self and other

    Args:
        other: another bounding box

    Returns:
        a new bounding box

    """
    return BoundingBox(xmin=min(self.xmin, other.xmin),
                       ymin=min(self.ymin, other.ymin),
                       xmax=max(self.xmax, other.xmax),
                       ymax=max(self.ymax, other.ymax))

coord_list_to_bbox(coords)

Computes the bounding box of multiple coordinates

Parameters:

Name Type Description Default
coords Tuple[Tuple[float]]

coordinates (x1, y1), ..., (xN, yN)

 required

Returns:

Type Description
BoundingBox

BoundingBox instance
Source code in scenes/spatial.py 
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
def coord_list_to_bbox(coords: Tuple[Tuple[float]]) -> BoundingBox:
    """
    Computes the bounding box of multiple coordinates

    Args:
        coords: coordinates (x1, y1), ..., (xN, yN)

    Returns:
        BoundingBox instance

    """
    xmin, xmax = math.inf, -math.inf
    ymin, ymax = math.inf, -math.inf
    for x, y in coords:
        xmin = min(xmin, x)
        xmax = max(xmax, x)
        ymin = min(ymin, y)
        ymax = max(ymax, y)

    return BoundingBox(xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax)

coordinates_transform(src_srs, tgt_srs)

Return a coordinates transform.

Parameters:

Name Type Description Default
src_srs SpatialReference

source CRS

 required
tgt_srs SpatialReference

target CRS

 required

Returns:

Type Description
CoordinateTransformation

osr.CoordinateTransformation
Source code in scenes/spatial.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
def coordinates_transform(
        src_srs: osr.SpatialReference,
        tgt_srs: osr.SpatialReference
) -> osr.CoordinateTransformation:
    """
    Return a coordinates transform.

    Args:
        src_srs: source CRS
        tgt_srs: target CRS

    Returns:
        osr.CoordinateTransformation

    """
    assert src_srs, "reproject_coords: src_srs is None!"
    assert tgt_srs, "reproject_coords: tgt_srs is None!"
    # Use x,y = lon, lat
    src_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
    tgt_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
    return osr.CoordinateTransformation(src_srs, tgt_srs)

coords2poly(coords)

Converts a list of coordinates into a polygon

Parameters:

Name Type Description Default
coords Tuple[Tuple[float]]

tuple of (x, y) coordinates

 required

Returns:

Type Description
Geometry

a polygon
Source code in scenes/spatial.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def coords2poly(coords: Tuple[Tuple[float]]) -> ogr.Geometry:
    """
    Converts a list of coordinates into a polygon

    Args:
        coords: tuple of (x, y) coordinates

    Returns:
        a polygon

    """
    ring = ogr.Geometry(ogr.wkbLinearRing)
    for coord in coords + (coords[0],):
        x, y = coord
        ring.AddPoint(x, y)
    poly = ogr.Geometry(ogr.wkbPolygon)
    poly.AddGeometry(ring)

    return poly

epsg2srs(epsg)

Return a Spatial Reference System corresponding to an EPSG

Parameters:

Name Type Description Default
epsg int

EPSG (int)

 required

Returns:

Type Description
SpatialReference

OSR spatial reference
Source code in scenes/spatial.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
def epsg2srs(epsg: int) -> osr.SpatialReference:
    """
    Return a Spatial Reference System corresponding to an EPSG

    Args:
        epsg: EPSG (int)

    Returns:
        OSR spatial reference

    """
    srs = osr.SpatialReference()
    srs.ImportFromEPSG(epsg)
    return srs

extent_overlap(extent, other_extent)

Returns the ratio of extents overlaps.

Parameters:

Name Type Description Default
extent Tuple[Tuple[float]]

extent

 required
other_extent Tuple[Tuple[float]]

other extent

 required

Returns:

Type Description
float

overlap (in the [0, 1] range). 0 -> no overlap with other_extent, 1 -> extent lies inside other_extent
Source code in scenes/spatial.py 
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
def extent_overlap(
        extent: Tuple[Tuple[float]],
        other_extent: Tuple[Tuple[float]]
) -> float:
    """
    Returns the ratio of extents overlaps.

    Args:
        extent: extent
        other_extent: other extent

    Returns:
        overlap (in the [0, 1] range). 0 -> no overlap with other_extent,
            1 -> extent lies inside other_extent

    """
    poly = coords2poly(extent)
    other_poly = coords2poly(other_extent)
    return poly_overlap(poly=poly, other_poly=other_poly)

poly_overlap(poly, other_poly)

Returns the ratio of polygons overlap.

Parameters:

Name Type Description Default
poly Geometry

polygon

 required
other_poly Geometry

other polygon

 required

Returns:

Type Description
float

overlap (in the [0, 1] range). 0 -> no overlap with other_poly, 1 -> poly is completely inside other_poly
Source code in scenes/spatial.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
def poly_overlap(poly: ogr.Geometry, other_poly: ogr.Geometry) -> float:
    """
    Returns the ratio of polygons overlap.

    Args:
        poly: polygon
        other_poly: other polygon

    Returns:
        overlap (in the [0, 1] range). 0 -> no overlap with other_poly,
            1 -> poly is completely inside other_poly

    """
    inter = poly.Intersection(other_poly)

    return inter.GetArea() / poly.GetArea()

reproject_coords(coords, src_srs, tgt_srs)

Reproject a list of x,y coordinates.

Parameters:

Name Type Description Default
coords List[Tuple[float]]

list of (x, y) tuples

 required
src_srs SpatialReference

source CRS

 required
tgt_srs SpatialReference

target CRS

 required

Returns:

Name Type Description
trans_coords Tuple[Tuple[float]]

coordinates in target CRS
Source code in scenes/spatial.py 
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
def reproject_coords(
        coords: List[Tuple[float]],
        src_srs: osr.SpatialReference,
        tgt_srs: osr.SpatialReference
) -> Tuple[Tuple[float]]:
    """
    Reproject a list of x,y coordinates.

    Args:
        coords: list of (x, y) tuples
        src_srs: source CRS
        tgt_srs: target CRS

    Returns:
        trans_coords: coordinates in target CRS

    """
    trans_coords = []
    transform = coordinates_transform(src_srs=src_srs, tgt_srs=tgt_srs)
    for x, y in coords:
        x, y, _ = transform.TransformPoint(x, y)
        trans_coords.append((x, y))

    return tuple(trans_coords)