shapely.LinearRing

shapely.LinearRing#

class LinearRing(coordinates=None)#

Geometry type composed of one or more line segments that forms a closed loop.

A LinearRing is a closed, one-dimensional feature. A LinearRing that crosses itself or touches itself at a single point is invalid and operations on it may fail.

Parameters:

coordinatessequence: A sequence of (x, y [,z]) numeric coordinate pairs or triples, or an array-like with shape (N, 2) or (N, 3). Also can be a sequence of Point objects.

Notes

Rings are automatically closed. There is no need to specify a final coordinate pair identical to the first.

Examples

Construct a square ring.

>>> ring = LinearRing( ((0, 0), (0, 1), (1 ,1 ), (1 , 0)) )
>>> ring.is_closed
True
>>> list(ring.coords)
[(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)]
>>> ring.length
4.0

almost_equals(other, decimal=6)#

Return True if all coordinates are equal to a specified decimal place.

Deprecated since version 1.8.0: The ‘almost_equals()’ method is deprecated and will be removed in Shapely 2.1 because the name is confusing. The ‘equals_exact()’ method should be used instead.

Refers to approximate coordinate equality, which requires coordinates to be approximately equal and in the same order for all components of a geometry.

Because of this it is possible for “equals()” to be True for two geometries and “almost_equals()” to be False.

Returns:

bool

Examples

>>> LineString(
...     [(0, 0), (2, 2)]
... ).equals_exact(
...     LineString([(0, 0), (1, 1), (2, 2)]),
...     1e-6
... )
False

property area#: Unitless area of the geometry (float).

property boundary#

Return a lower dimension geometry that bounds the object.

The boundary of a polygon is a line, the boundary of a line is a collection of points. The boundary of a point is an empty (null) collection.

property bounds#: Return minimum bounding region (minx, miny, maxx, maxy).

buffer(distance, quad_segs=16, cap_style='round', join_style='round', mitre_limit=5.0, single_sided=False, **kwargs)#

Get a geometry that represents all points within a distance of this geometry.

A positive distance produces a dilation, a negative distance an erosion. A very small or zero distance may sometimes be used to “tidy” a polygon.

Parameters:

distancefloat

The distance to buffer around the object.

resolutionint, optional

The resolution of the buffer around each vertex of the object.

quad_segsint, optional

Sets the number of line segments used to approximate an angle fillet.

cap_styleshapely.BufferCapStyle or {‘round’, ‘square’, ‘flat’}, default ‘round’

Specifies the shape of buffered line endings. BufferCapStyle.round (‘round’) results in circular line endings (see quad_segs). Both BufferCapStyle.square (‘square’) and BufferCapStyle.flat (‘flat’) result in rectangular line endings, only BufferCapStyle.flat (‘flat’) will end at the original vertex, while BufferCapStyle.square (‘square’) involves adding the buffer width.

join_styleshapely.BufferJoinStyle or {‘round’, ‘mitre’, ‘bevel’}, default ‘round’

Specifies the shape of buffered line midpoints. BufferJoinStyle.ROUND (‘round’) results in rounded shapes. BufferJoinStyle.bevel (‘bevel’) results in a beveled edge that touches the original vertex. BufferJoinStyle.mitre (‘mitre’) results in a single vertex that is beveled depending on the mitre_limit parameter.

mitre_limitfloat, optional

The mitre limit ratio is used for very sharp corners. The mitre ratio is the ratio of the distance from the corner to the end of the mitred offset corner. When two line segments meet at a sharp angle, a miter join will extend the original geometry. To prevent unreasonable geometry, the mitre limit allows controlling the maximum length of the join corner. Corners with a ratio which exceed the limit will be beveled.

single_sidedbool, optional

The side used is determined by the sign of the buffer distance:

a positive distance indicates the left-hand side a negative distance indicates the right-hand side

The single-sided buffer of point geometries is the same as the regular buffer. The End Cap Style for single-sided buffers is always ignored, and forced to the equivalent of CAP_FLAT.

quadsegsint, optional

Deprecated alias for quad_segs.

**kwargsdict, optional

For backwards compatibility of renamed parameters. If an unsupported kwarg is passed, a ValueError will be raised.

Returns:

Geometry

Notes

The return value is a strictly two-dimensional geometry. All Z coordinates of the original geometry will be ignored.

Examples

>>> from shapely.wkt import loads
>>> g = loads('POINT (0.0 0.0)')

16-gon approx of a unit radius circle:

>>> g.buffer(1.0).area  
3.1365484905459...

128-gon approximation:

>>> g.buffer(1.0, 128).area  
3.141513801144...

triangle approximation:

>>> g.buffer(1.0, 3).area
3.0
>>> list(g.buffer(1.0, cap_style=BufferCapStyle.square).exterior.coords)
[(1.0, 1.0), (1.0, -1.0), (-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)]
>>> g.buffer(1.0, cap_style=BufferCapStyle.square).area
4.0

property centroid#: Return the geometric center of the object.

contains(other)#: Return True if the geometry contains the other, else False.

contains_properly(other)#

Return True if the geometry completely contains the other.

There should be no common boundary points.

Refer to shapely.contains_properly for full documentation.

property convex_hull#

Return the convex hull of the geometry.

Imagine an elastic band stretched around the geometry: that’s a convex hull, more or less.

The convex hull of a three member multipoint, for example, is a triangular polygon.

property coords#: Access to geometry’s coordinates (CoordinateSequence).

covered_by(other)#: Return True if the geometry is covered by the other, else False.

covers(other)#: Return True if the geometry covers the other, else False.

crosses(other)#: Return True if the geometries cross, else False.

difference(other, grid_size=None)#

Return the difference of the geometries.

Refer to shapely.difference for full documentation.

disjoint(other)#: Return True if geometries are disjoint, else False.

distance(other)#: Unitless distance to other geometry (float).

dwithin(other, distance)#

Return True if geometry is within a given distance from the other.

Refer to shapely.dwithin for full documentation.

property envelope#: A figure that envelopes the geometry.

equals(other)#

Return True if geometries are equal, else False.

This method considers point-set equality (or topological equality), and is equivalent to (self.within(other) & self.contains(other)).

Returns:

bool

Examples

>>> LineString(
...     [(0, 0), (2, 2)]
... ).equals(
...     LineString([(0, 0), (1, 1), (2, 2)])
... )
True

equals_exact(other, tolerance=0.0, normalize=False)#

Return True if the geometries are equivalent within the tolerance.

Refer to equals_exact() for full documentation.

Parameters:

otherBaseGeometry: The other geometry object in this comparison.
tolerancefloat, optional (default: 0.): Absolute tolerance in the same units as coordinates.
normalizebool, optional (default: False): If True, normalize the two geometries so that the coordinates are in the same order.

Added in version 2.1.0.

Returns:

bool

Examples

>>> LineString(
...     [(0, 0), (2, 2)]
... ).equals_exact(
...     LineString([(0, 0), (1, 1), (2, 2)]),
...     1e-6
... )
False

property geom_type#: Name of the geometry’s type, such as ‘Point’.

geometryType()#: Get the geometry type (deprecated).

Deprecated since version 2.0: Use the geom_type attribute instead.

property has_m#: True if the geometry’s coordinate sequence(s) have m values.

property has_z#: True if the geometry’s coordinate sequence(s) have z values.

hausdorff_distance(other)#: Unitless hausdorff distance to other geometry (float).

interpolate(distance, normalized=False)#

Return a point at the specified distance along a linear geometry.

Negative length values are taken as measured in the reverse direction from the end of the geometry. Out-of-range index values are handled by clamping them to the valid range of values. If the normalized arg is True, the distance will be interpreted as a fraction of the geometry’s length.

Alias of line_interpolate_point.

intersection(other, grid_size=None)#

Return the intersection of the geometries.

Refer to shapely.intersection for full documentation.

intersects(other)#: Return True if geometries intersect, else False.

property is_ccw#: True is the ring is oriented counter clock-wise.

property is_closed#

True if the geometry is closed, else False.

Applicable only to linear geometries.

property is_empty#: True if the set of points in this geometry is empty, else False.

property is_ring#: True if the geometry is a closed ring, else False.

property is_simple#

True if the geometry is simple.

Simple means that any self-intersections are only at boundary points.

property is_valid#

True if the geometry is valid.

The definition depends on sub-class.

property length#: Unitless length of the geometry (float).

line_interpolate_point(distance, normalized=False)#

Return a point at the specified distance along a linear geometry.

Alias of interpolate.

line_locate_point(other, normalized=False)#

Return the distance of this geometry to a point nearest the specified point.

If the normalized arg is True, return the distance normalized to the length of the linear geometry.

Alias of project.

property minimum_clearance#: Unitless distance a node can be moved to produce an invalid geometry (float).

property minimum_rotated_rectangle#

Return the oriented envelope (minimum rotated rectangle) of the geometry.

Unlike envelope this rectangle is not constrained to be parallel to the coordinate axes. If the convex hull of the object is a degenerate (line or point) this degenerate is returned.

Alias of oriented_envelope.

normalize()#

Convert geometry to normal form (or canonical form).

This method orders the coordinates, rings of a polygon and parts of multi geometries consistently. Typically useful for testing purposes (for example in combination with equals_exact).

Examples

>>> from shapely import MultiLineString
>>> line = MultiLineString([[(0, 0), (1, 1)], [(3, 3), (2, 2)]])
>>> line.normalize()
<MULTILINESTRING ((2 2, 3 3), (0 0, 1 1))>

offset_curve(distance, quad_segs=16, join_style=BufferJoinStyle.round, mitre_limit=5.0)#

Return a (Multi)LineString at a distance from the object.

The side, left or right, is determined by the sign of the distance parameter (negative for right side offset, positive for left side offset). The resolution of the buffer around each vertex of the object increases by increasing the quad_segs keyword parameter.

The join style is for outside corners between line segments. Accepted values are JOIN_STYLE.round (1), JOIN_STYLE.mitre (2), and JOIN_STYLE.bevel (3).

The mitre ratio limit is used for very sharp corners. It is the ratio of the distance from the corner to the end of the mitred offset corner. When two line segments meet at a sharp angle, a miter join will extend far beyond the original geometry. To prevent unreasonable geometry, the mitre limit allows controlling the maximum length of the join corner. Corners with a ratio which exceed the limit will be beveled.

Note: the behaviour regarding orientation of the resulting line depends on the GEOS version. With GEOS < 3.11, the line retains the same direction for a left offset (positive distance) or has reverse direction for a right offset (negative distance), and this behaviour was documented as such in previous Shapely versions. Starting with GEOS 3.11, the function tries to preserve the orientation of the original line.

property oriented_envelope#

Return the oriented envelope (minimum rotated rectangle) of a geometry.

Unlike envelope this rectangle is not constrained to be parallel to the coordinate axes. If the convex hull of the object is a degenerate (line or point) this degenerate is returned.

Alias of minimum_rotated_rectangle.

overlaps(other)#: Return True if geometries overlap, else False.

parallel_offset(distance, side='right', resolution=16, join_style=BufferJoinStyle.round, mitre_limit=5.0)#

Alternative method to offset_curve() method.

Older alternative method to the offset_curve() method, but uses resolution instead of quad_segs and a side keyword (‘left’ or ‘right’) instead of sign of the distance. This method is kept for backwards compatibility for now, but is is recommended to use offset_curve() instead.

point_on_surface()#

Return a point guaranteed to be within the object, cheaply.

Alias of representative_point.

project(other, normalized=False)#

Return the distance of geometry to a point nearest the specified point.

If the normalized arg is True, return the distance normalized to the length of the linear geometry.

Alias of line_locate_point.

relate(other)#: Return the DE-9IM intersection matrix for the two geometries (string).

relate_pattern(other, pattern)#: Return True if the DE-9IM relationship code satisfies the pattern.

representative_point()#

Return a point guaranteed to be within the object, cheaply.

Alias of point_on_surface.

reverse()#

Return a copy of this geometry with the order of coordinates reversed.

If the geometry is a polygon with interior rings, the interior rings are also reversed.

Points are unchanged.

shapely.LinearRing

Contents

shapely.LinearRing#