def test_step(multiregion_with_region: Tuple[Multiregion, Segment]) -> None:
multiregion, segment = multiregion_with_region
first_region, *rest_multiregion = multiregion
result = segment_in_multiregion(segment, rest_multiregion)
next_result = segment_in_multiregion(segment, multiregion)
relation_with_first_region = segment_in_region(segment, first_region)
assert equivalence(
next_result is Relation.DISJOINT, result is Relation.DISJOINT
and relation_with_first_region is Relation.DISJOINT)
assert equivalence(
next_result is Relation.WITHIN, result is Relation.WITHIN
or relation_with_first_region is Relation.WITHIN)
assert equivalence(
next_result is Relation.COMPONENT, result is Relation.COMPONENT
or relation_with_first_region is Relation.COMPONENT)
assert equivalence(
next_result is Relation.CROSS, result is Relation.CROSS
or relation_with_first_region is Relation.CROSS)
assert equivalence(
next_result is Relation.TOUCH, result is Relation.TOUCH and
(relation_with_first_region is Relation.DISJOINT
or relation_with_first_region is Relation.TOUCH)
or result is Relation.DISJOINT
and relation_with_first_region is Relation.TOUCH)
def test_connection_with_contour_in_multipolygon(
multipolygon_with_region: Tuple[Multipolygon, Region]) -> None:
multipolygon, region = multipolygon_with_region
result = region_in_multipolygon(region, multipolygon)
contour_relation = contour_in_multipolygon(region, multipolygon)
assert implication(result is Relation.DISJOINT or result is Relation.COVER,
contour_relation is Relation.DISJOINT)
assert implication(
contour_relation is Relation.DISJOINT, result is Relation.DISJOINT
or result is Relation.OVERLAP or result is Relation.COVER)
assert implication(
result is Relation.TOUCH or result is Relation.ENCLOSES
or result is Relation.COMPOSITE, contour_relation is Relation.TOUCH)
assert implication(
contour_relation is Relation.TOUCH, result is Relation.TOUCH
or result is Relation.ENCLOSES or result is Relation.OVERLAP
or result is Relation.COMPOSITE)
assert implication(
result is Relation.OVERLAP, contour_relation is Relation.DISJOINT
or contour_relation is Relation.CROSS
or contour_relation is Relation.TOUCH)
assert implication(contour_relation is Relation.CROSS,
result is Relation.OVERLAP)
assert equivalence(
result is Relation.COMPONENT or result is Relation.EQUAL,
contour_relation is Relation.COMPONENT)
assert equivalence(result is Relation.ENCLOSED,
contour_relation is Relation.ENCLOSED)
assert equivalence(result is Relation.WITHIN,
contour_relation is Relation.WITHIN)
def test_equivalents(first: Expression,
second: Expression) -> None:
result = first < second
assert equivalence(result, second > first)
assert equivalence(result, second >= first != second)
assert equivalence(result, first <= second != first)
def test_connection_with_segment_in_contour(
region_with_segment: Tuple[Region, Segment]) -> None:
region, segment = region_with_segment
result = segment_in_region(segment, region)
relation_with_contour = segment_in_contour(segment, region)
assert implication(result is Relation.DISJOINT,
relation_with_contour is Relation.DISJOINT)
assert implication(
result is Relation.TOUCH, relation_with_contour is Relation.TOUCH
or relation_with_contour is Relation.OVERLAP)
assert equivalence(result is Relation.CROSS,
relation_with_contour is Relation.CROSS)
assert equivalence(result is Relation.COMPONENT,
relation_with_contour is Relation.COMPONENT)
assert implication(
result is Relation.ENCLOSED, relation_with_contour is Relation.TOUCH
or relation_with_contour is Relation.OVERLAP)
assert implication(result is Relation.WITHIN,
relation_with_contour is Relation.DISJOINT)
assert implication(
relation_with_contour is Relation.DISJOINT, result is Relation.DISJOINT
or result is Relation.WITHIN)
assert implication(relation_with_contour is Relation.TOUCH,
result is Relation.TOUCH or result is Relation.ENCLOSED)
assert implication(relation_with_contour is Relation.OVERLAP,
result is Relation.TOUCH or result is Relation.ENCLOSED)
def test_mixes_relations(mixes_pair: Tuple[Mix, Mix]) -> None:
left_mix, right_mix = mixes_pair
result = left_mix.relate(right_mix)
assert equivalence(
result is Relation.DISJOINT,
all(
left_component.relate(right_component) is Relation.DISJOINT
for left_component, right_component in product(
mix_to_components(left_mix), mix_to_components(right_mix))))
assert implication(
result is Relation.OVERLAP,
left_mix.shaped is right_mix.shaped is EMPTY
or left_mix.shaped is not EMPTY and right_mix.shaped is not EMPTY)
assert implication(result in (Relation.COVER, Relation.ENCLOSES),
right_mix.shaped is not EMPTY)
assert implication(
result is Relation.COMPOSITE,
all(component is EMPTY
or right_mix.relate(component) is Relation.COMPONENT
for component in mix_to_components(left_mix)))
assert equivalence(
result is Relation.EQUAL,
all(left_component is right_component is EMPTY or (
left_component.relate(right_component) is Relation.EQUAL)
for left_component, right_component in zip(
mix_to_components(left_mix), mix_to_components(right_mix))))
assert implication(
result is Relation.COMPONENT,
all(component is EMPTY
or left_mix.relate(component) is Relation.COMPONENT
for component in mix_to_components(right_mix)))
assert implication(result in (Relation.ENCLOSED, Relation.WITHIN),
left_mix.shaped is not EMPTY)
def test_convexity(polygon: Polygon) -> None:
result = polygon.perimeter
is_polygon_convex = polygon.is_convex
convex_hull_perimeter = polygon.convex_hull.perimeter
assert equivalence(not is_polygon_convex, result > convex_hull_perimeter)
assert equivalence(is_polygon_convex, result == convex_hull_perimeter)
def test_equivalents(compounds_pair: Tuple[Compound, Compound]) -> None:
first_compound, second_compound = compounds_pair
result = first_compound < second_compound
assert equivalence(result, second_compound > first_compound)
assert equivalence(result,
first_compound <= second_compound != first_compound)
assert equivalence(result,
second_compound >= first_compound != second_compound)
def test_step(multipolygon_with_multisegment: Tuple[Multipolygon, Multisegment]
) -> None:
multipolygon, multisegment = multipolygon_with_multisegment
first_segment, rest_multisegment = multisegment_pop_left(multisegment)
result = multisegment_in_multipolygon(rest_multisegment, multipolygon)
next_result = multisegment_in_multipolygon(multisegment, multipolygon)
relation_with_first_segment = segment_in_multipolygon(first_segment,
multipolygon)
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 not Relation.CROSS
or result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH)
assert implication(result is Relation.DISJOINT
and relation_with_first_segment is Relation.TOUCH
or result is Relation.TOUCH
and relation_with_first_segment is Relation.DISJOINT,
next_result is Relation.TOUCH)
assert equivalence(next_result is Relation.CROSS,
result is Relation.CROSS
or relation_with_first_segment is Relation.CROSS
or (bool(rest_multisegment.segments)
and result is Relation.DISJOINT
or result is Relation.TOUCH)
and (relation_with_first_segment is Relation.ENCLOSED
or relation_with_first_segment is Relation.WITHIN)
or (result is Relation.ENCLOSED
or result is Relation.WITHIN)
and (relation_with_first_segment is Relation.DISJOINT
or relation_with_first_segment is Relation.TOUCH))
assert equivalence(next_result is Relation.COMPONENT,
(not rest_multisegment.segments
or result is Relation.COMPONENT)
and relation_with_first_segment is Relation.COMPONENT)
assert equivalence(next_result is Relation.ENCLOSED,
not rest_multisegment.segments
and relation_with_first_segment is Relation.ENCLOSED
or (result is Relation.COMPONENT
or result is Relation.ENCLOSED)
and (relation_with_first_segment is Relation.ENCLOSED
or relation_with_first_segment is Relation.WITHIN)
or (result is Relation.ENCLOSED
or result is Relation.WITHIN)
and relation_with_first_segment is Relation.COMPONENT
or result is Relation.WITHIN
and relation_with_first_segment is Relation.ENCLOSED)
assert equivalence(next_result is Relation.WITHIN,
(not rest_multisegment.segments
or result is Relation.WITHIN)
and relation_with_first_segment is Relation.WITHIN)
def test_self(multipolygon: Multipolygon) -> None:
has_holes = any(polygon.holes for polygon in multipolygon.polygons)
assert equivalence(
all(
region_in_multipolygon(polygon.border, multipolygon) is
Relation.COMPONENT
for polygon in multipolygon.polygons), not has_holes)
assert equivalence(
any(
region_in_multipolygon(polygon.border, multipolygon) is
Relation.OVERLAP for polygon in multipolygon.polygons), has_holes)
def test_relations(polygons_pair: Tuple[Polygon, Polygon]) -> None:
left, right = polygons_pair
result = polygon_in_polygon(left, right)
complement = polygon_in_polygon(right, left)
assert equivalence(result is complement, result
in SYMMETRIC_COMPOUND_RELATIONS)
assert equivalence(
result is not complement, result.complement is complement
and result in ASYMMETRIC_UNIFORM_COMPOUND_RELATIONS
and complement in ASYMMETRIC_UNIFORM_COMPOUND_RELATIONS)
def test_relations(contours_pair: Tuple[Contour, Contour]) -> None:
left_contour, right_contour = contours_pair
result = contour_in_contour(left_contour, right_contour)
complement = contour_in_contour(right_contour, left_contour)
assert equivalence(result is complement, result
in SYMMETRIC_SAME_LINEAR_RELATIONS)
assert equivalence(
result is not complement, result.complement is complement
and result in ASYMMETRIC_LINEAR_RELATIONS
and complement in ASYMMETRIC_LINEAR_RELATIONS)
def test_relations(segments_pair: Tuple[Segment, Segment]) -> None:
left_segment, right_segment = segments_pair
result = segment_in_segment(left_segment, right_segment)
complement = segment_in_segment(right_segment, left_segment)
assert equivalence(result is complement, result
in SYMMETRIC_SAME_LINEAR_RELATIONS)
assert equivalence(
result is not complement, result.complement is complement
and result in ASYMMETRIC_LINEAR_RELATIONS
and complement in ASYMMETRIC_LINEAR_RELATIONS)
def test_relations(regions_pair: Tuple[Region, Region]) -> None:
left_region, right_region = regions_pair
result = region_in_region(left_region, right_region)
complement = region_in_region(right_region, left_region)
assert equivalence(result is complement,
result in SYMMETRIC_COMPOUND_RELATIONS)
assert equivalence(result is not complement,
result.complement is complement
and result in ASYMMETRIC_UNIFORM_COMPOUND_RELATIONS
and complement in ASYMMETRIC_UNIFORM_COMPOUND_RELATIONS)
def test_commutativity(context_with_segments_pair
: Tuple[Context, Tuple[Segment, Segment]]) -> None:
context, (first, second) = context_with_segments_pair
result = context.segments_relation(first, second)
complement = context.segments_relation(second, first)
assert equivalence(result is complement,
result in SYMMETRIC_LINEAR_RELATIONS)
assert equivalence(result is not complement,
result.complement is complement
and result in ASYMMETRIC_LINEAR_RELATIONS
and complement in ASYMMETRIC_LINEAR_RELATIONS)
def test_relations(multiregions_pair: Tuple[Multiregion, Multiregion]) -> None:
left_multiregion, right_multiregion = multiregions_pair
result = multiregion_in_multiregion(left_multiregion, right_multiregion)
complement = multiregion_in_multiregion(right_multiregion,
left_multiregion)
assert equivalence(result is complement, result
in SYMMETRIC_COMPOUND_RELATIONS)
assert equivalence(
result is not complement, result.complement is complement
and result in ASYMMETRIC_MULTIPART_COMPOUND_RELATIONS
and complement in ASYMMETRIC_MULTIPART_COMPOUND_RELATIONS)
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_connection_with_contains(
compound_with_point: Tuple[Compound, Point]) -> None:
compound, point = compound_with_point
result = compound.distance_to(point)
assert equivalence(not result, point in compound)
def test_basic(first_pair: BoundPortedBeachLineKeysPair,
second_pair: BoundPortedBeachLineKeysPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(first_bound < second_bound,
first_ported < second_ported)
def test_basic(first_pair: BoundPortedSetsPair,
second_pair: BoundPortedSetsPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(first_bound <= second_bound,
first_ported <= second_ported)
def test_basic(first_pair: BoundPortedCharClassBuildersPair,
second_pair: BoundPortedCharClassBuildersPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(first_bound == second_bound,
first_ported == second_ported)
def test_basic(pair: BoundPortedSourceCategoriesPair,
geometry_categories: BoundPortedGeometryCategoriesPair) -> None:
bound, ported = pair
bound_geometry_category, ported_geometry_category = geometry_categories
assert equivalence(bound.belongs(bound_geometry_category),
ported.belongs(ported_geometry_category))
def test_basic(first_edges_pair: BoundPortedEdgesPair,
second_edges_pair: BoundPortedEdgesPair) -> None:
first_bound, first_ported = first_edges_pair
second_bound, second_ported = second_edges_pair
assert equivalence(first_bound == second_bound,
first_ported == second_ported)
def test_defaults(pair: AlternativeNativeSetsPair) -> None:
alternative, native = pair
alternative_result, native_result = alternative.pop(), native.pop()
assert equivalence(alternative_result not in alternative, native_result
not in native)
def test_basic(first_pair: BoundPortedBoxesPair,
second_pair: BoundPortedBoxesPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(first_bound.inside_of(second_bound),
first_ported.inside_of(second_ported))
def test_basic(first_pair: BoundPortedRingManagersPair,
second_pair: BoundPortedRingManagersPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(first_bound == second_bound,
first_ported == second_ported)
def test_basic(first_trapezoids_pair: BoundPortedTrapezoidsPair,
second_trapezoids_pair: BoundPortedTrapezoidsPair) -> None:
first_bound, first_ported = first_trapezoids_pair
second_bound, second_ported = second_trapezoids_pair
assert equivalence(first_bound == second_bound,
first_ported == second_ported)
def test_connection_with_disjoint(
compounds_pair: Tuple[Compound, Compound]) -> None:
left_compound, right_compound = compounds_pair
result = left_compound.distance_to(right_compound)
assert equivalence(bool(result), left_compound.disjoint(right_compound))
def test_basic(first_pair: BoundPortedBoundsPair,
second_pair: BoundPortedBoundsPair) -> None:
first_bound, first_ported = first_pair
second_bound, second_ported = second_pair
assert equivalence(bound(first_bound, second_bound),
ported(first_ported, second_ported))
def test_basic(first_pair: AlternativeNativeIntsPair,
second_pair: AlternativeNativeIntsPair) -> None:
alternative_first, native_first = first_pair
alternative_second, native_second = second_pair
assert equivalence(alternative_first == alternative_second,
native_first == native_second)
def test_commutative_case(segments_pair: SegmentsPair) -> None:
first, second = segments_pair
result = subtract_segments(first, second)
assert equivalence(result == subtract_segments(second, first),
first == second)
