def indicesToBBOX(indices, src_img):
""" Takes indices from DG image and returns the BBOX in coordinates of transform.
:param indices: list
:param src_img: raster data
:return: Shapely POLYGON
"""
min_coords = xy(src_img.transform, indices[1], indices[2])
max_coords = xy(src_img.transform, indices[0], indices[3])
return box(min_coords[0], min_coords[1], max_coords[0], max_coords[1])
def test_xy_gcps_rpcs(dataset, transform_attr, coords, expected):
with rasterio.open(dataset, 'r') as src:
transform = getattr(src, transform_attr)
if transform_attr == 'gcps':
transform = transform[0]
for coord, truth in zip(coords, expected):
assert xy(transform, *coord) == pytest.approx(truth)
# check offset behaviour
assert xy(transform, 0, 0, offset='lr') == \
xy(transform, 0, 1, offset='ll') == \
xy(transform, 1, 1, offset='ul') == \
xy(transform, 1, 0, offset='ur')
def to_xarray(self, columns, dim_name="time", nodata=0, dtype="uint8"):
"""
Convert a data column to a xarray data array.
Parameters
----------
columns : str or list of str
name or names of the data columns.
dim_name : str
name of the outermost dimension set by the `columns` argument.
nodata : numeric
value to be assigned to pixels with no data.
dtype : str or numpy dtype
the data type.
Returns
-------
da : xr.DataArray
A xarray data array.
"""
x = self[self.x_column].values
y = self[self.y_column].values
xres, yres = self.res
i = (y - min(y)) // yres
j = (x - min(x)) // xres
# ensure that `columns` is a list
if isinstance(columns, str):
columns = [columns]
# use a head-tail iteration pattern to get the array shape and prepare
# the pixel coordinates
arr = self._to_ndarray(columns[0], i, j, nodata, dtype)
num_rows, num_cols = arr.shape
_transform = self.get_transform()
cols = np.arange(num_cols)
rows = np.arange(num_rows)
x_coords, _ = transform.xy(_transform, cols, cols)
_, y_coords = transform.xy(_transform, rows, rows)
return xr.DataArray(
[arr] + [
self._to_ndarray(column, i, j, nodata, dtype)
for column in columns[1:]
],
dims=[dim_name, self.y_column, self.x_column],
coords={
self.x_column: x_coords,
self.y_column: y_coords,
dim_name: columns,
},
attrs=dict(nodata=nodata, pyproj_srs=f"epsg:{self.crs.to_epsg()}"),
)
def get_ref_da(geom, res, fill=0, crs=None):
if crs is None:
crs = settings.CRS
ref_transform, (ref_height, ref_width) = _calculate_transform(geom, res)
rows = np.arange(ref_height)
cols = np.arange(ref_width)
xs, _ = transform.xy(ref_transform, cols, cols)
_, ys = transform.xy(ref_transform, rows, rows)
ref_da = xr.DataArray(fill, dims=('y', 'x'), coords={'y': ys, 'x': xs})
ref_da.attrs['pyproj_srs'] = crs
return ref_da
def test_xy_rowcol_inverse():
# TODO this is an ideal candiate for
# property-based testing with hypothesis
aff = Affine.identity()
rows_cols = ([0, 0, 10, 10],
[0, 10, 0, 10])
assert rows_cols == rowcol(aff, *xy(aff, *rows_cols))
def array2Coords(transform, row, col):
"""
* convert between array position and coords
* params are row,col (y,x) as expected by rasterio
* returns coords at the CENTRE of the cell
"""
return xy(transform, row, col)
def map_pixels_to_coordinates(reference_tiff, dst_epsg, pixels):
"""We are assuming that the pixels are a list of tuples. For example: [(row1, col1), (row2, col2)]"""
rows = [row for (row, _) in pixels]
cols = [col for (_, col) in pixels]
xs, ys = transform.xy(reference_tiff.transform, rows, cols)
dst_crs = rio.crs.CRS.from_epsg(dst_epsg)
return map_to_new_crs(reference_tiff.crs, dst_crs, xs, ys)
def get_cropped_profile(profile: dict, slice_x: slice, slice_y: slice):
"""
slice_x and slice_y are numpy slices
"""
x_start = slice_x.start or 0
y_start = slice_y.start or 0
x_stop = slice_x.stop or profile['width']
y_stop = slice_y.stop or profile['height']
width = x_stop - x_start
height = y_stop - y_start
profile_cropped = profile.copy()
trans = profile['transform']
x_cropped, y_cropped = xy(trans, y_start, x_start, offset='ul')
trans_list = list(trans.to_gdal())
trans_list[0] = x_cropped
trans_list[3] = y_cropped
tranform_cropped = Affine.from_gdal(*trans_list)
profile_cropped['transform'] = tranform_cropped
profile_cropped['height'] = height
profile_cropped['width'] = width
return profile_cropped
def array2Coords(a, row, col): """ * convert between array position and coords * params are row,col (y,x) as expected by rasterio * returns coords at the CENTRE of the cell """ x, y = xy(a, row, col) return int(x), int(y)
def grid_x(self):
try:
return self._grid_x
except AttributeError:
cols = np.arange(self.meta['width'])
x, _ = transform.xy(self.meta['transform'], cols, cols)
self._grid_x = x
return self._grid_x
def grid_y(self):
try:
return self._grid_y
except AttributeError:
rows = np.arange(self.meta['height'])
_, y = transform.xy(self.meta['transform'], rows, rows)
self._grid_y = y
return self._grid_y
def rowcol_to_latlon(row, col, res=250):
row = np.asarray(row) if type(row) is list else row
col = np.asarray(col) if type(col) is list else col
x, y = xy(Affine(*albers_conus_transform(res)), row, col)
p1 = Proj(CRS.from_wkt(albers_conus_crs()))
p2 = Proj(proj='latlong', datum='WGS84')
lon, lat = transform(p1, p2, x, y)
return lat, lon
def getCoordinates(dstransform, width_df):
new_data = {'lon': [], 'lat': [], 'width_lons': [], 'width_lats': []}
for idx, row in width_df.iterrows():
lon, lat = transform.xy(dstransform, row['coli'], row['rowi'])
new_data['lon'].append(lon)
new_data['lat'].append(lat)
width_lons, width_lats = transform.xy(dstransform, row['width_coli'],
row['width_rowi'])
new_data['width_lons'].append(width_lons)
new_data['width_lats'].append(width_lats)
width_df['lon'] = new_data['lon']
width_df['lat'] = new_data['lat']
width_df['width_lons'] = new_data['width_lons']
width_df['width_lats'] = new_data['width_lats']
return width_df
def getCoordinates(dstransform, width_df):
new_data = {'x': [], 'y': [], 'width_x': [], 'width_y': []}
for idx, row in width_df.iterrows():
x, y = transform.xy(dstransform, row['coli'], row['rowi'])
new_data['x'].append(x)
new_data['y'].append(y)
width_x, width_y = transform.xy(dstransform, row['width_coli'],
row['width_rowi'])
new_data['width_x'].append(width_x)
new_data['width_y'].append(width_y)
width_df['x'] = new_data['x']
width_df['y'] = new_data['y']
width_df['width_x'] = new_data['width_x']
width_df['width_y'] = new_data['width_y']
return width_df
def spatial_position(x: int, y: int, transform: Affine) -> list:
"""
CONVERT PIXEL COORDINATE TO SPATIAL COORDINATES
:param transform:
:param x:
:param y:
:return:
"""
return xy(transform, x, y)
def ul(self, row, col):
"""Returns the coordinates (x, y) of the upper left corner of a
pixel at `row` and `col` in the units of the dataset's
coordinate reference system.
Deprecated; Use `xy(row, col, offset='ul')` instead.
"""
warnings.warn("ul method is deprecated. Use xy(row, col, offset='ul')",
DeprecationWarning)
return xy(self.transform, row, col, offset='ul')
def ul(self, row, col):
"""Returns the coordinates (x, y) of the upper left corner of a
pixel at `row` and `col` in the units of the dataset's
coordinate reference system.
Deprecated; Use `xy(row, col, offset='ul')` instead.
"""
warnings.warn("ul method is deprecated. Use xy(row, col, offset='ul')",
DeprecationWarning)
return xy(self.transform, row, col, offset='ul')
def test_xy():
aff = Affine(300.0379266750948, 0.0, 101985.0, 0.0, -300.041782729805,
2826915.0)
ul_x, ul_y = aff * (0, 0)
xoff = aff.a
yoff = aff.e
assert xy(aff, 0, 0, offset='ul') == (ul_x, ul_y)
assert xy(aff, 0, 0, offset='ur') == (ul_x + xoff, ul_y)
assert xy(aff, 0, 0, offset='ll') == (ul_x, ul_y + yoff)
expected = (ul_x + xoff, ul_y + yoff)
assert xy(aff, 0, 0, offset='lr') == expected
expected = (ul_x + xoff / 2, ul_y + yoff / 2)
assert xy(aff, 0, 0, offset='center') == expected
assert xy(aff, 0, 0, offset='lr') == \
xy(aff, 0, 1, offset='ll') == \
xy(aff, 1, 1, offset='ul') == \
xy(aff, 1, 0, offset='ur')
def test_xy():
aff = Affine(300.0379266750948, 0.0, 101985.0,
0.0, -300.041782729805, 2826915.0)
ul_x, ul_y = aff * (0, 0)
xoff = aff.a
yoff = aff.e
assert xy(aff, 0, 0, offset='ul') == (ul_x, ul_y)
assert xy(aff, 0, 0, offset='ur') == (ul_x + xoff, ul_y)
assert xy(aff, 0, 0, offset='ll') == (ul_x, ul_y + yoff)
expected = (ul_x + xoff, ul_y + yoff)
assert xy(aff, 0, 0, offset='lr') == expected
expected = (ul_x + xoff / 2, ul_y + yoff / 2)
assert xy(aff, 0, 0, offset='center') == expected
assert xy(aff, 0, 0, offset='lr') == \
xy(aff, 0, 1, offset='ll') == \
xy(aff, 1, 1, offset='ul') == \
xy(aff, 1, 0, offset='ur')
def get_xs_ys(cols, rows, transform):
"""
Computes rasters of x and y coordinates, based on row and column counts and a defined transform.
:param cols: list of ints, defining the column counts
:param rows: list of ints, defining the row counts
:param transform: np.ndarray, 1D, with 6 rasterio compatible transform parameters
:return: 2 np.ndarray (MxN): xs: x-coordinates, ys: y-coordinates, lons: longitude coordinates, lats: latitude coordinates
"""
xs, ys = xy(transform, rows, cols)
xs, ys = np.array(xs), np.array(ys)
return xs, ys
def pixel_to_map(self, pixel_point):
"""Transform point from pixel to map-based coordinates.
Args:
pixel_point: (x, y) tuple in pixel coordinates
Returns:
(x, y) tuple in map coordinates
"""
image_point = xy(self.transform, int(pixel_point[1]),
int(pixel_point[0]))
map_point = self.image2map.transform(*image_point)
return map_point
def sample_from_inhabitable_area(img, transform, sample_size=1):
# Get inhabitable areas , developed area code starts from 21 to 31
# Source: https://www.usgs.gov/centers/eros/science/
#national-land-cover-database?qt-science_center_objects=0
##qt-science_center_objects
amask = (img >= 21) & (img <= 31)
goodr, goodc = np.nonzero(amask)
# Get random locations sampling from goodr,goodc
r_choices = np.random.choice(np.arange(goodr.size), size=sample_size)
rs, cs = goodr[r_choices], goodc[r_choices]
# Translate back into north america coordinates which is EPSG4269'EPSG:4269
xs, ys = rtransform.xy(transform=transform, rows=rs, cols=cs)
lons, lats = rwarp.transform(src.crs, block_groups.crs, xs, ys)
return lons, lats
def make_geometry(clu, X, affine, crs, buffer_amount=100):
"""
Convert clusters cells into contigious convex hulls.
These are then buffered and overlapping polygons are merged.
Parameters
----------
clu : list of sets
The array of clusters with indices.
X : array-like, shape = [n_samples, n_features]
The list of points with coordinates.
affine : affine.Affine
Raster affine transformation.
crs : CRS
Coordinate reference system.
buffer_amount : int, default 100
Amount in metres by which to buffer polygons before merging.
Returns
-------
clusters : GeoDataFrame
The geometry-fied clusters.
"""
clusters = []
for c in clu:
coords = [X[loc] for loc in c]
coords_real = [xy(affine, loc[0], loc[1]) for loc in coords]
m = MultiPoint(coords_real)
clusters.append(m.wkt)
gdf = pd.DataFrame(clusters)
geometry = gdf[0].map(shapely.wkt.loads)
gdf = gdf.drop(0, axis=1)
gdf = gpd.GeoDataFrame(gdf, crs=crs, geometry=geometry)
gdf["geometry"] = gdf.geometry.convex_hull
buffer_amount /= 1e5 # divide by 100K for rough conversion to degrees
gdf["geometry"] = gdf.geometry.buffer(buffer_amount)
gdf = merge_overlap(gdf)
gdf["geometry"] = gdf.geometry.convex_hull
gdf = merge_overlap(gdf)
print("Number of clusters:", len(gdf))
return gdf
def get_utm_zone(crs, transform, shape):
"""
Calculates the UTM zone for the image center
:param crs: image crs
:param transform: image transform
:param size: image size [height, width]
:return: UTM zone in format 'EPSG:32XYZ'
"""
#find image extents
#todo: check for image size!
#if it is more than 600 km longitude - recommend not to transform to utm at once
#find image center
center_xy = xy(transform, shape[0] / 2, shape[1] / 2)
center_latlon = warp.transform(crs, CRS_LATLON, [center_xy[0]],
[center_xy[1]])
#calc zone
return _utm_zone(center_latlon[1][0], center_latlon[0][0])
def get_cropped_profile(profile: dict, slice_x: slice, slice_y: slice) -> dict:
"""
This is a tool for using a reference profile and numpy slices (i.e.
np.s_[start: stop]) to create a new profile that is within the window of
slice_x, slice_y.
Parameters
----------
profile : dict
The reference rasterio profile.
slice_x : slice
The horizontal slice.
slice_y : slice
The vertical slice.
Returns
-------
dict:
The rasterio dictionary from cropping.
"""
x_start = slice_x.start or 0
y_start = slice_y.start or 0
x_stop = slice_x.stop or profile['width']
y_stop = slice_y.stop or profile['height']
if (x_start < 0) | (x_stop < 0) | (y_start < 0) | (y_stop < 0):
raise ValueError('Slices must be positive')
width = x_stop - x_start
height = y_stop - y_start
profile_cropped = profile.copy()
trans = profile['transform']
x_cropped, y_cropped = xy(trans, y_start, x_start, offset='ul')
trans_list = list(trans.to_gdal())
trans_list[0] = x_cropped
trans_list[3] = y_cropped
tranform_cropped = Affine.from_gdal(*trans_list)
profile_cropped['transform'] = tranform_cropped
profile_cropped['height'] = height
profile_cropped['width'] = width
return profile_cropped
def load_dem(to_load, meta=None):
"""Loads and transforms a Digital Elevation Model (DEM) image
into a DataFrame.
Parameters
----------
to_load : str or arr
path to raster or an in-memory array with DEM data
meta : dict, optional
dictionary of raster attributes, must include width,
height, transform, and crs
Returns
-------
df : DataFrame
flattened raster with additional derived fields
"""
if isinstance(to_load, str):
with rasterio.open(to_load) as src:
dem = src.read()
meta = src.meta
elif isinstance(to_load, np.ndarray) and meta is not None:
dem = to_load
else:
raise TypeError
df = pd.DataFrame(columns=['elevation', 'lat', 'lon'])
df['elevation'] = dem.ravel()
df['elevation'] = df['elevation'].astype('Int64')
# fetch lat and lon for each pixel in a raster
rows, cols = np.indices((meta['height'], meta['width']))
xs, ys = transform.xy(meta['transform'], cols.ravel(), rows.ravel())
lons, lats = warp.transform(meta['crs'], {'init': 'EPSG:4326'}, xs, ys)
df['lat'] = lats
df['lon'] = lons
# nodata represented as -32768
df.loc[df.elevation == -32768] = np.nan
return df
def get_utm_zone(crs, transform, shape):
"""
Calculates the UTM zone for the image center
:param crs: image crs
:param transform: image transform
:param shape: image size [height, width]
:return: rasterio CRS of given UTM zone
"""
# find image extents
# todo: check for image size!
# if it is more than 600 km longitude, or crosses the equator, or 80N/ 80S line
# - recommend not to transform to utm at once
# find image center
center_xy = xy(transform, shape[0] / 2, shape[1] / 2)
center_latlon = warp.transform(crs, CRS_LATLON, [center_xy[0]],
[center_xy[1]])
#calc zone
return _utm_zone(center_latlon[1][0], center_latlon[0][0])
def xy(self, row, col, offset="center"):
"""Returns the coordinates ``(x, y)`` of a pixel at `row` and `col`.
The pixel's center is returned by default, but a corner can be returned
by setting `offset` to one of `ul, ur, ll, lr`.
Parameters
----------
row : int
Pixel row.
col : int
Pixel column.
offset : str, optional
Determines if the returned coordinates are for the center of the
pixel or for a corner.
Returns
-------
tuple
``(x, y)``
"""
return xy(self.transform, row, col, offset=offset)
def xy(self, row, col, offset="center"):
"""Returns the coordinates ``(x, y)`` of a pixel at `row` and `col`.
The pixel's center is returned by default, but a corner can be returned
by setting `offset` to one of `ul, ur, ll, lr`.
Parameters
----------
row : int
Pixel row.
col : int
Pixel column.
offset : str, optional
Determines if the returned coordinates are for the center of the
pixel or for a corner.
Returns
-------
tuple
``(x, y)``
"""
return xy(self.transform, row, col, offset=offset)
def get_zonal_stats_from_point(self,
point: Vector3) -> List[Optional[Dict]]:
results = []
if self.boundary_data:
for plugin in (x for x in (self.terrain_data, self.attribute_data,
self.flow_dir_data, self.flow_dir_data)
if x is not None):
if plugin is self.terrain_data:
var = self._elevation_attribute.selected
elif plugin is self.attribute_data:
var = self._attribute.selected
else:
var = ''
raster = plugin.get_data(var)
affine = plugin.affine
res = plugin.resolution
var_stats = plugin.variable_stats(var)
nodata = var_stats.nodata_value
# Transform point coordinates to crs of raster
p = shapely.geometry.Point(
*transform.xy(affine, point.x / res, point.y / res))
zones = []
for feat in self.boundary_data.get_features():
if shapely.geometry.shape(feat['geometry']).contains(p):
zones.append(feat)
# Retrieve zonal stats for this raster
result = zonal_stats(zones,
raster,
affine=affine,
nodata=nodata,
add_stats=self.zonal_stats)
for j, row in enumerate(result):
row['Name'] = "{} (Zone {})".format(
plugin.data_name, zones[j].get('id'))
results.append(row)
return results
def get_zonal_stats_from_feature(
self, feature: LinearRing) -> List[Optional[Dict]]:
results = []
if self.terrain_data:
# Normalize feature coordinates to terrain resolution
t_res = self.terrain_data.resolution
normalized_coords = [(p[0] / t_res, p[1] / t_res)
for p in feature.coords]
for plugin in (x for x in (self.terrain_data, self.attribute_data,
self.flow_dir_data, self.flow_dir_data)
if x is not None):
if plugin is self.terrain_data:
var = self._elevation_attribute.selected
elif plugin is self.attribute_data:
var = self._attribute.selected
else:
var = ''
raster = plugin.get_data(var, Timeline.app().current)
affine = plugin.affine
var_stats = plugin.variable_stats(var)
nodata = var_stats.nodata_value
feat = Polygon(
*[[transform.xy(affine, *p) for p in normalized_coords]])
# Transform normalized raster coordinates to CRS of raster to query and obtain results
result = zonal_stats(feat,
raster,
affine=affine,
nodata=nodata,
add_stats=self.zonal_stats)[0]
result['Name'] = plugin.data_name
results.append(result)
return results
def raster_to_lines(guess_skel_in):
"""
Convert thinned raster to linestring geometry.
Parameters
----------
guess_skel_in : path-like
Output from thin().
Returns
-------
guess_gdf : GeoDataFrame
Converted to geometry.
"""
rast = rasterio.open(guess_skel_in)
arr = rast.read(1)
affine = rast.transform
max_row = arr.shape[0]
max_col = arr.shape[1]
lines = []
for row in range(0, max_row):
for col in range(0, max_col):
loc = (row, col)
if arr[loc] == 1:
for i in range(-1, 2):
for j in range(-1, 2):
next_row = row + i
next_col = col + j
next_loc = (next_row, next_col)
# ensure we're within bounds
# ensure we're not looking at the same spot
if (
next_row < 0
or next_col < 0
or next_row >= max_row
or next_col >= max_col
or next_loc == loc
):
continue
if arr[next_loc] == 1:
line = (loc, next_loc)
rev = (line[1], line[0])
if line not in lines and rev not in lines:
lines.append(line)
real_lines = []
for line in lines:
real = (xy(affine, line[0][0], line[0][1]), xy(affine, line[1][0], line[1][1]))
real_lines.append(real)
shapes = []
for line in real_lines:
shapes.append(LineString([Point(line[0]), Point(line[1])]).wkt)
guess_gdf = pd.DataFrame(shapes)
geometry = guess_gdf[0].map(shapely.wkt.loads)
guess_gdf = guess_gdf.drop(0, axis=1)
guess_gdf = gpd.GeoDataFrame(guess_gdf, crs=rast.crs, geometry=geometry)
guess_gdf["same"] = 0
guess_gdf = guess_gdf.dissolve(by="same")
return guess_gdf
def test_xy_rowcol_inverse():
# TODO this is an ideal candiate for
# property-based testing with hypothesis
aff = Affine.identity()
rows_cols = ([0, 0, 10, 10], [0, 10, 0, 10])
assert rows_cols == rowcol(aff, *xy(aff, *rows_cols))
def test_bogus_offset():
with pytest.raises(ValueError):
xy(None, 1, 0, offset='bogus')
def test_bogus_offset():
with pytest.raises(ValueError):
xy(None, 1, 0, offset='bogus')