def clip_lines_by_polygon(lines, polygon,
closed=True,
check_input=True):
"""Clip multiple lines by polygon
Input
line: Sequence of polylines: [[p0, p1, ...], [q0, q1, ...], ...]
where pi and qi are point coordinates (x, y).
Output
polygon: list of vertices of polygon or the corresponding numpy array
closed: (optional) determine whether points on boundary should be
regarded as belonging to the polygon (closed = True)
or not (closed = False) - False is not recommended here
check_input: Allows faster execution if set to False
Outputs
inside_line_segments: Clipped line segments that are inside polygon
outside_line_segments: Clipped line segments that are outside polygon
This is a wrapper around clip_line_by_polygon
"""
if check_input:
# Input checks
msg = 'Keyword argument "closed" must be boolean'
if not isinstance(closed, bool):
raise RuntimeError(msg)
for i in range(len(lines)):
try:
lines[i] = ensure_numeric(lines[i], numpy.float)
except Exception, e:
msg = ('Line could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
try:
polygon = ensure_numeric(polygon, numpy.float)
except Exception, e:
msg = ('Polygon could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
def intersection(line0, line1, rtol=1.0e-12, atol=1.0e-12):
"""Returns intersecting point between two line segments.
However, if parallel lines coincide partly (i.e. share a common segment),
the line segment where lines coincide is returned
Inputs:
line0, line1: Each defined by two end points as in:
[[x0, y0], [x1, y1]]
A line can also be a 2x2 numpy array with each row
corresponding to a point.
rtol, atol: Tolerances passed onto numpy.allclose
Output:
status, value - where status and value is interpreted as follows:
status == 0: no intersection, value set to None.
status == 1: intersection point found and returned in value as [x,y].
status == 2: Collinear overlapping lines found.
Value takes the form [[x0,y0], [x1,y1]] which is the
segment common to both lines.
status == 3: Collinear non-overlapping lines. Value set to None.
status == 4: Lines are parallel. Value set to None.
"""
line0 = ensure_numeric(line0, numpy.float)
line1 = ensure_numeric(line1, numpy.float)
x0, y0 = line0[0, :]
x1, y1 = line0[1, :]
x2, y2 = line1[0, :]
x3, y3 = line1[1, :]
denom = (y3 - y2) * (x1 - x0) - (x3 - x2) * (y1 - y0)
u0 = (x3 - x2) * (y0 - y2) - (y3 - y2) * (x0 - x2)
u1 = (x2 - x0) * (y1 - y0) - (y2 - y0) * (x1 - x0)
if numpy.allclose(denom, 0.0, rtol=rtol, atol=atol):
# Lines are parallel - check if they are collinear
if numpy.allclose([u0, u1], 0.0, rtol=rtol, atol=atol):
# We now know that the lines are collinear
state = (point_on_line([x0, y0], line1, rtol=rtol, atol=atol),
point_on_line([x1, y1], line1, rtol=rtol, atol=atol),
point_on_line([x2, y2], line0, rtol=rtol, atol=atol),
point_on_line([x3, y3], line0, rtol=rtol, atol=atol))
return collinearmap[state]([x0, y0], [x1, y1],
[x2, y2], [x3, y3])
else:
# Lines are parallel but aren't collinear
return 4, None # FIXME (Ole): Add distance here instead of None
else:
# Lines are not parallel, check if they intersect
u0 = u0 / denom
u1 = u1 / denom
x = x0 + u0 * (x1 - x0)
y = y0 + u0 * (y1 - y0)
# Sanity check - can be removed to speed up if needed
if not numpy.allclose(x, x2 + u1 * (x3 - x2), rtol=rtol, atol=atol):
raise Exception
if not numpy.allclose(y, y2 + u1 * (y3 - y2), rtol=rtol, atol=atol):
raise Exception
# Check if point found lies within given line segments
if 0.0 <= u0 <= 1.0 and 0.0 <= u1 <= 1.0:
# We have intersection
return 1, numpy.array([x, y])
else:
# No intersection
return 0, None
def clip_line_by_polygon(line, polygon,
closed=True,
check_input=True):
"""Clip line segments by polygon
Input
line: Sequence of line nodes: [[x0, y0], [x1, y1], ...] or
the equivalent Nx2 numpy array
polygon: list of vertices of polygon or the corresponding numpy array
closed: (optional) determine whether points on boundary should be
regarded as belonging to the polygon (closed = True)
or not (closed = False) - False is not recommended here
check_input: Allows faster execution if set to False
Outputs
inside_lines: Clipped lines that are inside polygon
outside_lines: Clipped lines that are outside polygon
Both outputs take the form of lists of Nx2 line arrays
Example:
U = [[0,0], [1,0], [1,1], [0,1]] # Unit square
# Simple horizontal fully intersecting line
line = [[-1, 0.5], [2, 0.5]]
inside_line_segments, outside_line_segments = \
clip_line_by_polygon(line, polygon)
print numpy.allclose(inside_line_segments,
[[[0, 0.5], [1, 0.5]]])
print numpy.allclose(outside_line_segments,
[[[-1, 0.5], [0, 0.5]],
[[1, 0.5], [2, 0.5]]])
Remarks:
The assumptions listed in separate_points_by_polygon apply
Output line segments are listed as separate lines i.e. not joined
"""
if check_input:
# Input checks
msg = 'Keyword argument "closed" must be boolean'
if not isinstance(closed, bool):
raise RuntimeError(msg)
try:
line = ensure_numeric(line, numpy.float)
except Exception, e:
msg = ('Line could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
msg = 'Line segment array must be a 2d array of vertices'
if not len(line.shape) == 2:
raise RuntimeError(msg)
msg = 'Line array must have two columns'
if not line.shape[1] == 2:
raise RuntimeError(msg)
try:
polygon = ensure_numeric(polygon, numpy.float)
except Exception, e:
msg = ('Polygon could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
def point_on_line(points, line, rtol=1.0e-5, atol=1.0e-8):
"""Determine if a point is on a line segment
Input
points: Coordinates of either
* one point given by sequence [x, y]
* multiple points given by list of points or Nx2 array
line: Endpoint coordinates [[x0, y0], [x1, y1]] or
the equivalent 2x2 numeric array with each row corresponding
to a point.
rtol: Relative error for how close a point must be to be accepted
atol: Absolute error for how close a point must be to be accepted
Output
True or False
Notes
Line can be degenerate and function still works to discern coinciding
points from non-coinciding.
Tolerances rtol and atol are used with numpy.allclose()
"""
# Prepare input data
points = ensure_numeric(points)
line = ensure_numeric(line)
if len(points.shape) == 1:
# One point only - make into 1 x 2 array
points = points[numpy.newaxis, :]
one_point = True
else:
one_point = False
msg = 'Argument points must be either [x, y] or an Nx2 array of points'
if len(points.shape) != 2:
raise Exception(msg)
if not points.shape[0] > 0:
raise Exception(msg)
if points.shape[1] != 2:
raise Exception(msg)
N = points.shape[0] # Number of points
x = points[:, 0]
y = points[:, 1]
x0, y0 = line[0]
x1, y1 = line[1]
# Vector from beginning of line to point
a0 = x - x0
a1 = y - y0
# It's normal vector
a_normal0 = a1
a_normal1 = -a0
# Vector parallel to line
b0 = x1 - x0
b1 = y1 - y0
# Dot product
nominator = abs(a_normal0 * b0 + a_normal1 * b1)
denominator = b0 * b0 + b1 * b1
# Determine if point vector is parallel to line up to a tolerance
is_parallel = numpy.zeros(N, dtype=numpy.bool) # All False
is_parallel[nominator <= atol + rtol * denominator] = True
# Determine for points parallel to line if they are within end points
a0p = a0[is_parallel]
a1p = a1[is_parallel]
len_a = numpy.sqrt(a0p * a0p + a1p * a1p)
len_b = numpy.sqrt(b0 * b0 + b1 * b1)
cross = a0p * b0 + a1p * b1
# Initialise result to all False
result = numpy.zeros(N, dtype=numpy.bool)
# Result is True only if a0 * b0 + a1 * b1 >= 0 and len_a <= len_b
result[is_parallel] = (cross >= 0) * (len_a <= len_b)
# Return either boolean scalar or boolean vector
if one_point:
return result[0]
else:
return result
def separate_points_by_polygon(points, polygon,
closed=True,
check_input=True,
numpy_version=True):
"""Determine whether points are inside or outside a polygon
Input:
points - Tuple of (x, y) coordinates, or list of tuples
polygon - list of vertices of polygon
closed - (optional) determine whether points on boundary should be
regarded as belonging to the polygon (closed = True)
or not (closed = False)
check_input: Allows faster execution if set to False
Outputs:
indices: array of same length as points with indices of points falling
inside the polygon listed from the beginning and indices of points
falling outside listed from the end.
count: count of points falling inside the polygon
The indices of points inside are obtained as indices[:count]
The indices of points outside are obtained as indices[count:]
Examples:
U = [[0,0], [1,0], [1,1], [0,1]] # Unit square
separate_points_by_polygon( [[0.5, 0.5], [1, -0.5], [0.3, 0.2]], U)
will return the indices [0, 2, 1] and count == 2 as only the first
and the last point are inside the unit square
Remarks:
The vertices may be listed clockwise or counterclockwise and
the first point may optionally be repeated.
Polygons do not need to be convex.
Polygons can have holes in them and points inside a hole is
regarded as being outside the polygon.
Algorithm is based on work by Darel Finley,
http://www.alienryderflex.com/polygon/
"""
if check_input:
# Input checks
msg = 'Keyword argument "closed" must be boolean'
if not isinstance(closed, bool):
raise Exception(msg)
try:
points = ensure_numeric(points, numpy.float)
except Exception, e:
msg = ('Points could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
try:
polygon = ensure_numeric(polygon, numpy.float)
except Exception, e:
msg = ('Polygon could not be converted to numeric array: %s'
% str(e))
raise Exception(msg)
def interpolate(self, X, name=None, attribute_name=None):
"""Interpolate values of this vector layer to other layer
Input
X: Layer object defining target
name: Optional name of returned interpolated layer
attribute_name: Optional attribute name to use.
If None, all attributes are used.
FIXME (Ole): Single attribute not tested well yet
and not implemented for lines
Output
Y: Layer object with values of this vector layer interpolated to
geometry of input layer X
"""
msg = 'Input to Vector.interpolate must be a vector layer instance'
verify(X.is_vector, msg)
msg = ('Projections must be the same: I got %s and %s'
% (self.projection, X.projection))
verify(self.projection == X.projection, msg)
msg = ('Vector layer to interpolate from must be polygon geometry. '
'I got OGR geometry type %s'
% geometrytype2string(self.geometry_type))
verify(self.is_polygon_data, msg)
# FIXME (Ole): Organise this the same way it is done with rasters
original_geometry = X.get_geometry() # Geometry for returned data
if X.is_polygon_data:
# Use centroids, in case of polygons
X = convert_polygons_to_centroids(X)
elif X.is_line_data:
# Clip lines to polygon and return centroids
# FIXME (Ole): Need to separate this out, but identify what is
# common with points and lines
#
#X.write_to_file('line_data.shp')
#self.write_to_file('poly_data.shp')
# Extract line features
lines = X.get_geometry()
line_attributes = X.get_data()
N = len(X)
verify(len(lines) == N)
verify(len(line_attributes) == N)
# Extract polygon features
polygons = self.get_geometry()
poly_attributes = self.get_data()
verify(len(polygons) == len(poly_attributes))
# Data structure for resulting line segments
clipped_geometry = []
clipped_attributes = []
# Clip line lines to polygons
for i, polygon in enumerate(polygons):
for j, line in enumerate(lines):
inside, outside = clip_line_by_polygon(line, polygon)
# Create new attributes
# FIXME (Ole): Not done single specified polygon
# attribute
inside_attributes = {}
outside_attributes = {}
for key in line_attributes[j]:
inside_attributes[key] = line_attributes[j][key]
outside_attributes[key] = line_attributes[j][key]
for key in poly_attributes[i]:
inside_attributes[key] = poly_attributes[i][key]
outside_attributes[key] = None
# Always create default attribute flagging if segment was
# inside any of the polygons
inside_attributes[DEFAULT_ATTRIBUTE] = True
outside_attributes[DEFAULT_ATTRIBUTE] = False
# Assign new attribute set to clipped lines
for segment in inside:
clipped_geometry.append(segment)
clipped_attributes.append(inside_attributes)
for segment in outside:
clipped_geometry.append(segment)
clipped_attributes.append(outside_attributes)
# Create new Vector instance and return
V = Vector(data=clipped_attributes,
projection=X.get_projection(),
geometry=clipped_geometry,
geometry_type='line')
#V.write_to_file('clipped_and_tagged.shp')
return V
# The following applies only to Polygon-Point interpolation
msg = ('Vector layer to interpolate to must be point geometry. '
'I got OGR geometry type %s'
% geometrytype2string(X.geometry_type))
verify(X.is_point_data, msg)
msg = ('Name must be either a string or None. I got %s'
% (str(type(X)))[1:-1])
verify(name is None or isinstance(name, basestring), msg)
msg = ('Attribute must be either a string or None. I got %s'
% (str(type(X)))[1:-1])
verify(attribute_name is None or
isinstance(attribute_name, basestring), msg)
attribute_names = self.get_attribute_names()
if attribute_name is not None:
msg = ('Requested attribute "%s" did not exist in %s'
% (attribute_name, attribute_names))
verify(attribute_name in attribute_names, msg)
#----------------
# Start algorithm
#----------------
# Extract point features
points = ensure_numeric(X.get_geometry())
attributes = X.get_data()
N = len(X)
# Extract polygon features
geom = self.get_geometry()
data = self.get_data()
verify(len(geom) == len(data))
# Augment point features with empty attributes from polygon
for a in attributes:
if attribute_name is None:
# Use all attributes
for key in attribute_names:
a[key] = None
else:
# Use only requested attribute
# FIXME (Ole): Test for this is not finished
a[attribute_name] = None
# Always create default attribute flagging if point was
# inside any of the polygons
a[DEFAULT_ATTRIBUTE] = None
# Traverse polygons and assign attributes to points that fall inside
for i, polygon in enumerate(geom):
if attribute_name is None:
# Use all attributes
poly_attr = data[i]
else:
# Use only requested attribute
poly_attr = {attribute_name: data[i][attribute_name]}
# Assign default attribute to indicate points inside
poly_attr[DEFAULT_ATTRIBUTE] = True
# Clip data points by polygons and add polygon attributes
indices = inside_polygon(points, polygon)
for k in indices:
for key in poly_attr:
# Assign attributes from polygon to points
attributes[k][key] = poly_attr[key]
# Create new Vector instance and return
V = Vector(data=attributes,
projection=X.get_projection(),
geometry=original_geometry,
name=X.get_name())
return V
