def test_properties(segments: List[Segment]) -> None:
result = segments_to_multisegment(segments)
assert not segments_cross_or_overlap(result.segments)
assert equivalence(not segments_cross_or_overlap(segments),
sorted(result.segments,
key=segment_to_endpoints)
== sorted(map(to_sorted_segment, segments),
key=segment_to_endpoints))
def test_step(context: Context, segments: List[Segment]) -> None:
first_segment, *rest_segments = segments
result = segments_cross_or_overlap(rest_segments)
next_result = segments_cross_or_overlap(segments)
assert (next_result is (result or any(
context.segments_relation(first_segment, segment) in
(Relation.COMPONENT, Relation.COMPOSITE, Relation.CROSS,
Relation.EQUAL, Relation.OVERLAP) for segment in rest_segments)))
def test_step(segments: List[Segment]) -> None:
first_segment, *rest_segments = segments
result = segments_cross_or_overlap(rest_segments)
next_result = segments_cross_or_overlap(segments)
assert (next_result is (result or any(
segments_relationship(first_segment, segment) in
(SegmentsRelationship.CROSS, SegmentsRelationship.OVERLAP)
for segment in rest_segments)))
def validate(self) -> None:
"""
Checks if the multisegment is valid.
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.validate()
"""
segments = self.segments
if len(segments) < MIN_MULTISEGMENT_SEGMENTS_COUNT:
raise ValueError('Multisegment should have '
'at least {min_size} segments, '
'but found {size}.'
.format(min_size=MIN_MULTISEGMENT_SEGMENTS_COUNT,
size=len(segments)))
elif len(segments) > len(self._segments_set):
raise ValueError('Duplicate segments found.')
for segment in segments:
segment.validate()
if segments_cross_or_overlap(segments,
context=self._context):
raise ValueError('Crossing or overlapping segments found.')
def is_non_shaped_valid(object_: Any) -> bool:
points, segments = pack_non_shaped(object_)
return (not any(segment_contains_point(segment, point)
for point in points
for segment in segments)
and not segments_cross_or_overlap(segments,
context=_context))
def test_properties(segments: List[Segment]) -> None:
result = segments_to_multisegment(segments)
result_points, result_segments = pack_non_shaped(result)
assert not result_points
assert equivalence(
not segments_cross_or_overlap(segments),
are_segments_sequences_similar(result_segments, segments))
def validate(self) -> None:
"""
Checks if the multipolygon is valid.
Time complexity:
``O(vertices_count * log (vertices_count))``
Memory complexity:
``O(vertices_count)``
where
.. code-block:: python
vertices_count = sum(len(polygon.border.vertices)
+ sum(len(hole.vertices)
for hole in polygon.holes)
for polygon in self.polygons)
>>> from gon.base import Contour, Multipolygon, Point, Polygon
>>> multipolygon = Multipolygon(
... [Polygon(Contour([Point(0, 0), Point(14, 0), Point(14, 14),
... Point(0, 14)]),
... [Contour([Point(2, 2), Point(2, 12),
... Point(12, 12), Point(12, 2)])]),
... Polygon(Contour([Point(4, 4), Point(10, 4), Point(10, 10),
... Point(4, 10)]),
... [Contour([Point(6, 6), Point(6, 8), Point(8, 8),
... Point(8, 6)])])])
>>> multipolygon.validate()
"""
if len(self.polygons) < MIN_MULTIPOLYGON_POLYGONS_COUNT:
raise ValueError('Multipolygon should have '
'at least {min_size} polygons, '
'but found {size}.'.format(
min_size=MIN_MULTIPOLYGON_POLYGONS_COUNT,
size=len(self.polygons)))
elif len(self.polygons) > len(self._polygons_set):
raise ValueError('Duplicate polygons found.')
for polygon in self.polygons:
polygon.validate()
if segments_cross_or_overlap(list(
flatten(polygon.edges for polygon in self.polygons)),
context=self._context):
raise ValueError('Polygons should only touch each other '
'in discrete number of points.')
def are_segments_non_crossing_non_overlapping(segments: Sequence[Segment],
context: Context) -> bool:
return not segments_cross_or_overlap(segments, context=context)
def test_degenerate_segments(segments: List[Segment]) -> None:
with pytest.raises(ValueError):
segments_cross_or_overlap(segments)
def test_reversed_coordinates(segments: List[Segment]) -> None:
result = segments_cross_or_overlap(segments)
assert result is segments_cross_or_overlap(
reverse_segments_coordinates(segments))
def test_reversed_endpoints(segments: List[Segment]) -> None:
result = segments_cross_or_overlap(segments)
assert result is segments_cross_or_overlap(
[reverse_segment(segment) for segment in segments])
def test_reversed(segments: List[Segment]) -> None:
result = segments_cross_or_overlap(segments)
assert result is segments_cross_or_overlap(segments[::-1])
def test_base_case(segments: List[Segment]) -> None:
result = segments_cross_or_overlap(segments)
assert not result
def test_basic(segments: List[Segment]) -> None:
result = segments_cross_or_overlap(segments)
assert isinstance(result, bool)
def is_multisegment_valid(multisegment: Multisegment) -> bool:
return not segments_cross_or_overlap(multisegment.segments,
context=_context)
def segments_do_not_cross_or_overlap(segments: Sequence[Segment]) -> bool:
return not segments_cross_or_overlap(segments)
