def test_reversals(
context_with_segment_and_steps: Tuple[Context, Segment, Scalar, Scalar]
) -> None:
context, segment, step_x, step_y = context_with_segment_and_steps
result = context.translate_segment(segment, step_x, step_y)
assert reverse_segment(result) == context.translate_segment(
reverse_segment(segment), step_x, step_y)
assert reverse_segment_coordinates(result) == context.translate_segment(
reverse_segment_coordinates(segment), step_y, step_x)
def test_reversals(context_with_segments_pair
: Tuple[Context, Tuple[Segment, Segment]]) -> None:
context, (first, second) = context_with_segments_pair
result = context.segments_relation(first, second)
assert (result is context.segments_relation(reverse_segment(first), second)
is context.segments_relation(first, reverse_segment(second)))
assert result is context.segments_relation(
reverse_segment_coordinates(first),
reverse_segment_coordinates(second))
def test_reversals(segments_pair: Tuple[Segment, Segment]) -> None:
left_segment, right_segment = segments_pair
result = segment_in_segment(left_segment, right_segment)
assert result is segment_in_segment(reverse_segment(left_segment),
right_segment)
assert result is segment_in_segment(left_segment,
reverse_segment(right_segment))
assert result is segment_in_segment(
reverse_segment_coordinates(left_segment),
reverse_segment_coordinates(right_segment))
def test_reversals(segments_pair: SegmentsPair) -> None:
first, second = segments_pair
result = subtract_segments(first, second)
assert are_compounds_similar(
result, subtract_segments(reverse_segment(first), second))
assert result == subtract_segments(first, reverse_segment(second))
assert are_compounds_similar(
result,
reverse_compound_coordinates(
subtract_segments(reverse_segment_coordinates(first),
reverse_segment_coordinates(second))))
def test_reversals(
context_with_segments_pair: Tuple[Context, Tuple[Segment,
Segment]]) -> None:
context, (first, second) = context_with_segments_pair
result = context.segments_squared_distance(first, second)
assert (result == context.segments_squared_distance(
reverse_segment(first), second) == context.segments_squared_distance(
first, reverse_segment(second)))
assert result == context.segments_squared_distance(
reverse_segment_coordinates(first),
reverse_segment_coordinates(second))
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_reversals(polygon_with_segment: PolygonWithSegment) -> None:
polygon, segment = polygon_with_segment
result = symmetric_subtract_polygon_from_segment(segment, polygon)
assert are_compounds_similar(
result,
symmetric_subtract_polygon_from_segment(
segment, reverse_polygon_border(polygon)))
assert are_compounds_similar(
result,
symmetric_subtract_polygon_from_segment(
segment, reverse_polygon_holes(polygon)))
assert are_compounds_similar(
result,
symmetric_subtract_polygon_from_segment(
segment, reverse_polygon_holes_contours(polygon)))
assert are_compounds_similar(
result,
symmetric_subtract_polygon_from_segment(reverse_segment(segment),
polygon))
assert are_compounds_similar(
result,
reverse_compound_coordinates(
symmetric_subtract_polygon_from_segment(
reverse_segment_coordinates(segment),
reverse_polygon_coordinates(polygon))))
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_reversals(segment_with_point: Tuple[Segment, Point]) -> None:
segment, point = segment_with_point
result = point_in_segment(point, segment)
assert result is point_in_segment(point, reverse_segment(segment))
assert result is point_in_segment(reverse_point_coordinates(point),
reverse_segment_coordinates(segment))
def test_reversals(context_with_segment: Tuple[Context, Segment]) -> None:
context, segment = context_with_segment
result = context.segment_length(segment)
assert result == context.segment_length(reverse_segment(segment))
assert result == context.segment_length(
reverse_segment_coordinates(segment))
def test_endpoints_symmetry(context_with_box_and_segment
: Tuple[Context, Box, Segment]) -> None:
context, box, segment = context_with_box_and_segment
result = context.box_segment_squared_distance(box, segment)
assert result == context.box_segment_squared_distance(
box, reverse_segment(segment))
def test_reversals(region_with_segment: Tuple[Region, Segment]) -> None:
region, segment = region_with_segment
result = segment_in_region(segment, region)
assert result is segment_in_region(reverse_segment(segment), region)
assert result is segment_in_region(segment, reverse_contour(region))
assert result is segment_in_region(reverse_segment_coordinates(segment),
reverse_contour_coordinates(region))
def test_reversals(contour_with_segment: Tuple[Contour, Segment]) -> None:
contour, segment = contour_with_segment
result = segment_in_contour(segment, contour)
assert result is segment_in_contour(reverse_segment(segment), contour)
assert result is segment_in_contour(segment, reverse_contour(contour))
assert result is segment_in_contour(reverse_segment_coordinates(segment),
reverse_contour_coordinates(contour))
def test_reversals(context_with_segment_and_point
: Tuple[Context, Segment, Point]) -> None:
context, segment, point = context_with_segment_and_point
result = context.segment_point_squared_distance(segment, point)
assert result == context.segment_point_squared_distance(
reverse_segment(segment), point)
assert result == context.segment_point_squared_distance(
reverse_segment_coordinates(segment),
reverse_point_coordinates(point))
def test_reversals(
context_with_segment_and_point: Tuple[Context, Segment,
Point]) -> None:
context, segment, point = context_with_segment_and_point
result = context.segment_contains_point(segment, point)
assert result is context.segment_contains_point(reverse_segment(segment),
point)
assert result is context.segment_contains_point(
reverse_segment_coordinates(segment), reverse_point_coordinates(point))
def test_reversals(
context_with_segment_and_factors: Tuple[Context, Segment, Scalar, Scalar]
) -> None:
context, segment, factor_x, factor_y = context_with_segment_and_factors
result = context.scale_segment(segment, factor_x, factor_y)
assert reverse_geometry(result) == context.scale_segment(
reverse_segment(segment), factor_x, factor_y)
assert reverse_geometry_coordinates(result) == context.scale_segment(
reverse_segment_coordinates(segment), factor_y, factor_x)
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_reversals(polygon_with_segment: Tuple[Polygon, Segment]) -> None:
polygon, segment = polygon_with_segment
result = segment_in_polygon(segment, polygon)
assert result is segment_in_polygon(reverse_segment(segment), polygon)
assert result is segment_in_polygon(segment,
reverse_polygon_border(polygon))
assert result is segment_in_polygon(segment,
reverse_polygon_holes(polygon))
assert result is segment_in_polygon(
segment, reverse_polygon_holes_contours(polygon))
assert result is segment_in_polygon(reverse_segment_coordinates(segment),
reverse_polygon_coordinates(polygon))
def test_reversals(
multiregion_with_segment: Tuple[Multiregion, Segment]) -> None:
multiregion, segment = multiregion_with_segment
result = segment_in_multiregion(segment, multiregion)
assert result is segment_in_multiregion(reverse_segment(segment),
multiregion)
assert result is segment_in_multiregion(segment,
reverse_multiregion(multiregion))
assert result is segment_in_multiregion(
segment, reverse_multiregion_regions(multiregion))
assert result is segment_in_multiregion(
reverse_segment_coordinates(segment),
reverse_multiregion_coordinates(multiregion))
def test_reversals(
multipolygon_with_segment: Tuple[Multipolygon, Segment]) -> None:
multipolygon, segment = multipolygon_with_segment
result = segment_in_multipolygon(segment, multipolygon)
assert result is segment_in_multipolygon(reverse_segment(segment),
multipolygon)
assert result is segment_in_multipolygon(
segment, reverse_multipolygon(multipolygon))
assert result is segment_in_multipolygon(
segment, reverse_multipolygon_borders(multipolygon))
assert result is segment_in_multipolygon(
segment, reverse_multipolygon_holes(multipolygon))
assert result is segment_in_multipolygon(
segment, reverse_multipolygon_holes_contours(multipolygon))
assert result is segment_in_multipolygon(
reverse_segment_coordinates(segment),
reverse_multipolygon_coordinates(multipolygon))
def test_reversals(multisegment_with_segment: MultisegmentWithSegment) -> None:
multisegment, segment = multisegment_with_segment
result = unite_segment_with_multisegment(segment, multisegment)
assert are_compounds_similar(
result, unite_segment_with_multisegment(
segment, reverse_multisegment(multisegment)))
assert are_compounds_similar(
result, unite_segment_with_multisegment(
segment, reverse_multisegment_endpoints(multisegment)))
assert are_compounds_similar(
result, unite_segment_with_multisegment(reverse_segment(segment),
multisegment))
assert are_compounds_similar(
result, reverse_compound_coordinates(
unite_segment_with_multisegment(
reverse_segment_coordinates(segment),
reverse_multisegment_coordinates(multisegment))))
def test_reversals(polygon_with_segment: PolygonWithSegment
) -> None:
polygon, segment = polygon_with_segment
result = complete_intersect_segment_with_polygon(segment, polygon)
assert result == complete_intersect_segment_with_polygon(
segment, reverse_polygon_border(polygon))
assert result == complete_intersect_segment_with_polygon(
segment, reverse_polygon_holes(polygon))
assert result == complete_intersect_segment_with_polygon(
segment, reverse_polygon_holes_contours(polygon))
assert result == complete_intersect_segment_with_polygon(
reverse_segment(segment), polygon)
assert are_compounds_similar(
result, reverse_compound_coordinates(
complete_intersect_segment_with_polygon(
reverse_segment_coordinates(segment),
reverse_polygon_coordinates(polygon))))
def test_reversals(multisegment_with_segment: MultisegmentWithSegment) -> None:
multisegment, segment = multisegment_with_segment
result = symmetric_subtract_multisegment_from_segment(
segment, multisegment)
assert are_compounds_similar(
result,
symmetric_subtract_multisegment_from_segment(
segment, reverse_multisegment(multisegment)))
assert are_compounds_similar(
result,
symmetric_subtract_multisegment_from_segment(
segment, reverse_multisegment_endpoints(multisegment)))
assert are_compounds_similar(
result,
symmetric_subtract_multisegment_from_segment(reverse_segment(segment),
multisegment))
assert are_compounds_similar(
result,
reverse_compound_coordinates(
symmetric_subtract_multisegment_from_segment(
reverse_segment_coordinates(segment),
reverse_multisegment_coordinates(multisegment))))
def test_reversals(segment: Segment) -> None:
assert segment == reverse_segment(segment)
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_endpoints(segments: List[Segment]) -> None:
result = segments_intersect(segments)
assert result is segments_intersect(
[reverse_segment(segment) for segment in segments])
def test_reversals(segment: Segment) -> None:
assert hash(segment) == hash(reverse_segment(segment))
