def test_rotations(
multisegment_with_segment: Tuple[Multisegment, Segment]) -> None:
multisegment, segment = multisegment_with_segment
result = segment_in_multisegment(segment, multisegment)
assert all(result is segment_in_multisegment(segment, rotated)
for rotated in multisegment_rotations(multisegment))
def test_reversals(
multisegment_with_segment: Tuple[Multisegment, Segment]) -> None:
multisegment, segment = multisegment_with_segment
result = segment_in_multisegment(segment, multisegment)
assert result is segment_in_multisegment(reverse_segment(segment),
multisegment)
assert result is segment_in_multisegment(
segment, reverse_multisegment(multisegment))
assert result is segment_in_multisegment(
reverse_segment_coordinates(segment),
reverse_multisegment_coordinates(multisegment))
def test_properties(
polygon_with_multisegment: PolygonWithMultisegment) -> None:
polygon, multisegment = polygon_with_multisegment
result = intersect_multisegment_with_polygon(multisegment, polygon)
result_points, result_segments = pack_non_shaped(result)
assert not result_points
assert all(
segment_in_multisegment(result_segment, multisegment) in (
Relation.EQUAL, Relation.COMPONENT)
for result_segment in result_segments)
assert all(
segment_in_polygon(result_segment, polygon) in (Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)
for result_segment in result_segments)
assert all(
to_sorted_segment(segment) in result_segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result_segments)
for segment in multisegment.segments
if (segment_in_polygon(segment, polygon) in (Relation.CROSS,
Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)))
def test_properties(
polygon_with_multisegment: PolygonWithMultisegment) -> None:
polygon, multisegment = polygon_with_multisegment
result = subtract_polygon_from_multisegment(multisegment, polygon)
result_points, result_segments = pack_non_shaped(result)
assert not result_points
assert all(
segment_in_multisegment(result_segment, multisegment) in (
Relation.EQUAL, Relation.COMPONENT)
for result_segment in result_segments)
assert all(
segment_in_polygon(result_segment, polygon) in (Relation.DISJOINT,
Relation.TOUCH)
for result_segment in result_segments)
assert all(
segment in result_segments
or reverse_segment(segment) in result_segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result_segments)
for segment in multisegment.segments
if (segment_in_polygon(segment, polygon) in (Relation.DISJOINT,
Relation.CROSS)))
def test_properties(
multipolygon_with_multisegment: MultipolygonWithMultisegment) -> None:
multipolygon, multisegment = multipolygon_with_multisegment
result = intersect_multisegment_with_multipolygon(multisegment,
multipolygon)
assert all(
segment_in_multisegment(segment, multisegment) in (Relation.EQUAL,
Relation.COMPONENT)
for segment in result.segments)
assert all(
segment_in_multipolygon(segment, multipolygon) in (Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)
for segment in result.segments)
assert all(
to_sorted_segment(segment) in result.segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result.segments)
for segment in multisegment.segments
if (segment_in_multipolygon(segment, multipolygon) in (
Relation.CROSS, Relation.COMPONENT, Relation.ENCLOSED,
Relation.WITHIN)))
def test_properties(
multipolygon_with_multisegment: MultipolygonWithMultisegment) -> None:
multipolygon, multisegment = multipolygon_with_multisegment
result = subtract_multipolygon_from_multisegment(multisegment,
multipolygon)
assert all(
segment_in_multisegment(segment, multisegment) in (Relation.EQUAL,
Relation.COMPONENT)
for segment in result.segments)
assert all(
segment_in_multipolygon(segment, multipolygon) in (Relation.DISJOINT,
Relation.TOUCH)
for segment in result.segments)
assert all(
segment in result.segments
or reverse_segment(segment) in result.segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result.segments)
for segment in multisegment.segments
if (segment_in_multipolygon(segment, multipolygon) in (
Relation.DISJOINT, Relation.CROSS)))
def test_basic(
multisegment_with_segment: Tuple[Multisegment, Segment]) -> None:
multisegment, segment = multisegment_with_segment
result = segment_in_multisegment(segment, multisegment)
assert isinstance(result, Relation)
assert result in SAME_LINEAR_RELATIONS
def test_properties(
multisegment_with_segment: MultisegmentWithSegment) -> None:
multisegment, segment = multisegment_with_segment
result = symmetric_subtract_multisegment_from_segment(
segment, multisegment)
assert equivalence(
is_empty(result),
segment_in_multisegment(segment, multisegment) is Relation.EQUAL)
def test_connection_with_point_in_multisegment(
multisegment_with_segment: Tuple[Multisegment, Segment]) -> None:
multisegment, segment = multisegment_with_segment
result = segment_in_multisegment(segment, multisegment)
assert implication(
result is Relation.DISJOINT,
point_in_multisegment(segment.start, multisegment) is
point_in_multisegment(segment.end, multisegment) is Location.EXTERIOR)
def test_properties(multisegments_pair: MultisegmentsPair) -> None:
left_multisegment, right_multisegment = multisegments_pair
result = complete_intersect_multisegments(left_multisegment,
right_multisegment)
result_multipoint, result_multisegment = result
assert all(
point_in_multisegment(point, left_multisegment) is
point_in_multisegment(point, right_multisegment) is Relation.COMPONENT
for point in result_multipoint.points)
assert (multisegment_in_multisegment(left_multisegment, right_multisegment)
is not Relation.TOUCH or bool(result_multipoint))
assert all(
all(point in result_multipoint or any(
point in segment for segment in result_multisegment.segments)
for right_segment in right_multisegment.segments
for point in segments_intersections(left_segment, right_segment))
for left_segment in left_multisegment.segments
if (segment_in_multisegment(left_segment, right_multisegment) in (
Relation.TOUCH, Relation.CROSS)))
assert all(
segment_in_multisegment(segment, left_multisegment) in (
Relation.EQUAL, Relation.COMPONENT)
for segment in result_multisegment.segments)
assert all(
segment_in_multisegment(segment, right_multisegment) in (
Relation.EQUAL, Relation.COMPONENT)
for segment in result_multisegment.segments)
assert all(
to_sorted_segment(left_segment) in result_multisegment.segments or any(
segment_in_segment(segment, left_segment) is Relation.COMPONENT
for segment in result_multisegment.segments)
for left_segment in left_multisegment.segments if any(
segments_relation(left_segment.start, left_segment.end,
right_segment.start, right_segment.end) not in (
Relation.CROSS, Relation.DISJOINT,
Relation.TOUCH)
for right_segment in right_multisegment.segments))
def test_properties(multisegment_with_segment: MultisegmentWithSegment
) -> None:
multisegment, segment = multisegment_with_segment
result = unite_segment_with_multisegment(segment, multisegment)
relation = segment_in_multisegment(segment, multisegment)
assert equivalence(is_multisegment(result),
relation in (Relation.DISJOINT, Relation.TOUCH,
Relation.CROSS, Relation.OVERLAP,
Relation.COMPONENT))
assert equivalence(is_segment(result),
relation is Relation.EQUAL
or relation is Relation.COMPOSITE)
def test_properties(multisegments_pair: MultisegmentsPair) -> None:
first, second = multisegments_pair
result = complete_intersect_multisegments(first, second)
result_points, result_segments = pack_non_shaped(result)
assert all(
point_in_multisegment(point, first) is point_in_multisegment(
point, second) is Location.BOUNDARY for point in result_points)
assert (multisegment_in_multisegment(first, second) is not Relation.TOUCH
or bool(result_points))
assert all(
all(point in result_points or any(
point == result_segment.start or point == result_segment.end
for result_segment in result_segments)
for second_segment in second.segments
for point in segments_intersections(first_segment, second_segment))
for first_segment in first.segments
if (segment_in_multisegment(first_segment, second) in (
Relation.TOUCH, Relation.CROSS)))
assert all(
segment_in_multisegment(result_segment, first) in (Relation.EQUAL,
Relation.COMPONENT)
for result_segment in result_segments)
assert all(
segment_in_multisegment(result_segment, second) in (Relation.EQUAL,
Relation.COMPONENT)
for result_segment in result_segments)
assert all(
to_sorted_segment(first_segment) in result_segments or any(
segment_in_segment(result_segment, first_segment) is
Relation.COMPONENT for result_segment in result_segments)
for first_segment in first.segments if any(
segments_relation(first_segment, second_segment) not in (
Relation.CROSS, Relation.DISJOINT, Relation.TOUCH)
for second_segment in second.segments))
def test_properties(
multipolygon_with_multisegment: MultipolygonWithMultisegment) -> None:
multipolygon, multisegment = multipolygon_with_multisegment
result = complete_intersect_multisegment_with_multipolygon(
multisegment, multipolygon)
result_multipoint, result_multisegment = result
assert all(
point_in_multisegment(point, multisegment) is Relation.COMPONENT
for point in result_multipoint.points)
assert all(
point_in_multipolygon(point, multipolygon) is Relation.COMPONENT
for point in result_multipoint.points)
assert all(
any(
point_in_segment(point, segment) is Relation.COMPONENT
for point in result_multipoint.points) or any(
segments_relation(segment.start, segment.end, result_segment.
start, result_segment.end) is Relation.TOUCH
for result_segment in result_multisegment.segments)
for segment in multisegment.segments if
(segment_in_multipolygon(segment, multipolygon) is Relation.TOUCH
and all(
segments_relation(segment.start, segment.end, edge_start,
edge_end) in (Relation.CROSS, Relation.DISJOINT,
Relation.TOUCH)
for contour in to_multipolygon_contours(multipolygon)
for edge_start, edge_end in contour_to_edges_endpoints(contour))))
assert all(
segment_in_multisegment(segment, multisegment) in (Relation.EQUAL,
Relation.COMPONENT)
for segment in result_multisegment.segments)
assert all(
segment_in_multipolygon(segment, multipolygon) in (Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)
for segment in result_multisegment.segments)
assert all(
to_sorted_segment(segment) in result_multisegment.segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result_multisegment.segments)
for segment in multisegment.segments
if (segment_in_multipolygon(segment, multipolygon) in (
Relation.CROSS, Relation.COMPONENT, Relation.ENCLOSED,
Relation.WITHIN)))
def test_properties(
polygon_with_multisegment: PolygonWithMultisegment) -> None:
polygon, multisegment = polygon_with_multisegment
result = complete_intersect_multisegment_with_polygon(
multisegment, polygon)
result_points, result_segments = pack_non_shaped(result)
assert all(
point_in_multisegment(point, multisegment) is Location.BOUNDARY
for point in result_points)
assert all(
point_in_polygon(point, polygon) is Location.BOUNDARY
for point in result_points)
assert all(
any(
point_in_segment(point, segment) is Location.BOUNDARY
for point in result_points) or any(
segments_relation(segment, result_segment) is Relation.TOUCH
for result_segment in result_segments)
for segment in multisegment.segments
if (segment_in_polygon(segment, polygon) is Relation.TOUCH and all(
segments_relation(segment, contour_segment) in (Relation.CROSS,
Relation.DISJOINT,
Relation.TOUCH)
for contour in to_polygon_contours(polygon)
for contour_segment in to_contour_segments(contour))))
assert all(
segment_in_multisegment(result_segment, multisegment) in (
Relation.EQUAL, Relation.COMPONENT)
for result_segment in result_segments)
assert all(
segment_in_polygon(result_segment, polygon) in (Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)
for result_segment in result_segments)
assert all(
to_sorted_segment(segment) in result_segments
# in case of cross
or any(
segment_in_segment(result_segment, segment) is Relation.COMPONENT
for result_segment in result_segments)
for segment in multisegment.segments
if (segment_in_polygon(segment, polygon) in (Relation.CROSS,
Relation.COMPONENT,
Relation.ENCLOSED,
Relation.WITHIN)))
def test_properties(multisegment_with_segment: MultisegmentWithSegment
) -> None:
multisegment, segment = multisegment_with_segment
result = subtract_multisegment_from_segment(segment, multisegment)
relation = segment_in_multisegment(segment, multisegment)
assert equivalence(is_empty(result),
relation is Relation.EQUAL
or relation is Relation.COMPONENT)
assert implication(is_multisegment(result),
relation in (Relation.TOUCH, Relation.CROSS,
Relation.COMPOSITE, Relation.OVERLAP))
assert implication(is_segment(result),
relation in (Relation.DISJOINT, Relation.TOUCH,
Relation.CROSS, Relation.COMPOSITE,
Relation.OVERLAP))
def relate(self, other: Compound[Coordinate]) -> Relation:
"""
Finds relation between the contour and the other geometry.
Time complexity:
``O(vertices_count * log vertices_count)``
Memory complexity:
``O(vertices_count)``
where ``vertices_count = len(self.vertices)``.
>>> from gon.base import Contour, Point, Relation
>>> contour = Contour([Point(0, 0), Point(1, 0), Point(0, 1)])
>>> contour.relate(contour) is Relation.EQUAL
True
"""
return (relate_multipoint_to_linear_compound(other, self)
if isinstance(other, Multipoint) else
(segment_in_multisegment(other, self) if isinstance(
other, Segment) else
(multisegment_in_multisegment(other, self) if isinstance(
other, Linear) else other.relate(self).complement)))
def relate(self, other: Compound[Coordinate]) -> Relation:
"""
Finds relation between the multisegment and the other geometry.
Time complexity:
``O(segments_count * log segments_count)``
Memory complexity:
``O(segments_count)``
where ``segments_count = len(self.segments)``.
>>> from gon.base import Multisegment, Point, Segment
>>> multisegment = Multisegment([Segment(Point(0, 0), Point(1, 0)),
... Segment(Point(0, 1), Point(1, 1))])
>>> multisegment.relate(multisegment) is Relation.EQUAL
True
"""
return (relate_multipoint_to_linear_compound(other, self)
if isinstance(other, Multipoint)
else (segment_in_multisegment(other, self)
if isinstance(other, Segment)
else (multisegment_in_multisegment(other, self)
if isinstance(other, Multisegment)
else other.relate(self).complement)))
def test_step(multisegment_with_segment: Tuple[Multisegment, Segment]) -> None:
multisegment, segment = multisegment_with_segment
first_segment, rest_multisegment = multisegment_pop_left(multisegment)
result = segment_in_multisegment(segment, rest_multisegment)
next_result = segment_in_multisegment(segment, multisegment)
relation_with_first_segment = segment_in_segment(segment, first_segment)
assert equivalence(
next_result is Relation.DISJOINT, result is Relation.DISJOINT
and relation_with_first_segment is Relation.DISJOINT)
assert implication(
next_result is Relation.TOUCH, result is Relation.TOUCH and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH)
or result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH)
assert implication(
result is Relation.TOUCH
and relation_with_first_segment is Relation.DISJOINT
or result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH,
next_result is Relation.TOUCH)
assert implication(
next_result is Relation.CROSS, result is Relation.DISJOINT
and relation_with_first_segment is Relation.CROSS
or result is Relation.TOUCH and
(relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS)
or result is Relation.CROSS and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS))
assert implication((result is Relation.DISJOINT or result is Relation.TOUCH
or result is Relation.CROSS)
and relation_with_first_segment is Relation.CROSS
or result is Relation.CROSS and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH),
next_result is Relation.CROSS)
assert implication(
next_result is Relation.OVERLAP,
(result is Relation.DISJOINT and rest_multisegment.segments
or result is Relation.TOUCH or result is Relation.CROSS)
and relation_with_first_segment is Relation.COMPOSITE
or result is Relation.OVERLAP or result is Relation.COMPOSITE and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.OVERLAP)
or relation_with_first_segment is Relation.OVERLAP)
assert implication(
(result is Relation.DISJOINT and rest_multisegment.segments
or result is Relation.TOUCH or result is Relation.CROSS)
and relation_with_first_segment is Relation.COMPONENT
or result is Relation.OVERLAP and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS)
or (result is Relation.DISJOINT or result is Relation.TOUCH
or result is Relation.CROSS)
and relation_with_first_segment is Relation.OVERLAP,
next_result is Relation.OVERLAP)
assert implication(
next_result is Relation.COMPOSITE,
(not rest_multisegment.segments or result is Relation.COMPOSITE)
and relation_with_first_segment is Relation.COMPOSITE)
assert implication(
not rest_multisegment.segments
and relation_with_first_segment is Relation.COMPOSITE,
next_result is Relation.COMPOSITE)
assert implication(
next_result is Relation.EQUAL, not rest_multisegment.segments
and relation_with_first_segment is Relation.EQUAL
or result is Relation.COMPOSITE
and relation_with_first_segment is Relation.COMPOSITE)
assert implication(
not rest_multisegment.segments
and relation_with_first_segment is Relation.EQUAL,
next_result is Relation.EQUAL)
assert implication(
next_result is Relation.COMPONENT, result is Relation.COMPONENT
or relation_with_first_segment is Relation.COMPONENT
or result is Relation.OVERLAP and
(relation_with_first_segment is Relation.COMPOSITE
or relation_with_first_segment is Relation.OVERLAP)
or relation_with_first_segment is Relation.COMPONENT)
def test_self(multisegment: Multisegment) -> None:
assert all(
segment_in_multisegment(segment, multisegment) is Relation.COMPONENT
for segment in multisegment.segments)
def test_step(multisegments_pair: Tuple[Multisegment, Multisegment]) -> None:
left, right = multisegments_pair
first_segment, rest_left = multisegment_pop_left(left)
result = multisegment_in_multisegment(rest_left, right)
next_result = multisegment_in_multisegment(left, right)
relation_with_first_segment = segment_in_multisegment(first_segment, right)
assert equivalence(
next_result is Relation.DISJOINT,
result is relation_with_first_segment is Relation.DISJOINT)
assert implication(
next_result is Relation.TOUCH, result is Relation.TOUCH and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH)
or result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH)
assert implication(
result is Relation.TOUCH
and relation_with_first_segment is Relation.DISJOINT
or result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH,
next_result is Relation.TOUCH)
assert implication(
next_result is Relation.CROSS, result is Relation.CROSS and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS)
or (result is Relation.DISJOINT or result is Relation.TOUCH)
and relation_with_first_segment is Relation.CROSS
or result is Relation.TOUCH
and relation_with_first_segment is Relation.TOUCH)
assert implication(
result is Relation.CROSS and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS)
or (result is Relation.DISJOINT or result is Relation.TOUCH)
and relation_with_first_segment is Relation.CROSS,
next_result is Relation.CROSS)
assert implication(
next_result is Relation.OVERLAP, result is Relation.OVERLAP
or relation_with_first_segment is Relation.OVERLAP
or (result is Relation.DISJOINT and bool(rest_left.segments)
or result is Relation.TOUCH or result is Relation.CROSS)
and relation_with_first_segment is Relation.COMPONENT
or result is Relation.COMPONENT and
(relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH
or relation_with_first_segment is Relation.CROSS))
assert implication(
next_result is Relation.COMPOSITE, result is Relation.COMPOSITE
or relation_with_first_segment is Relation.COMPOSITE
or result is Relation.OVERLAP and
(relation_with_first_segment is Relation.COMPONENT
or relation_with_first_segment is Relation.OVERLAP)
or bool(rest_left.segments)
and relation_with_first_segment is Relation.EQUAL
or result is Relation.EQUAL or result is Relation.COMPONENT
and relation_with_first_segment is Relation.OVERLAP)
assert implication(
result is Relation.COMPOSITE
or relation_with_first_segment is Relation.COMPOSITE
or bool(rest_left.segments)
and relation_with_first_segment is Relation.EQUAL
or result is Relation.EQUAL, next_result is Relation.COMPOSITE)
assert implication(
next_result is Relation.EQUAL, not rest_left.segments
and relation_with_first_segment is Relation.EQUAL
or result is relation_with_first_segment is Relation.COMPONENT)
assert implication(
not rest_left.segments
and relation_with_first_segment is Relation.EQUAL,
next_result is Relation.EQUAL)
assert implication(next_result is Relation.COMPONENT,
(not rest_left.segments or result is Relation.COMPONENT)
and relation_with_first_segment is Relation.COMPONENT)
assert implication(
not rest_left.segments
and relation_with_first_segment is Relation.COMPONENT,
next_result is Relation.COMPONENT)