def test_reversals(region_with_contour: Tuple[Region, Contour]) -> None:
region, contour = region_with_contour
result = contour_in_region(contour, region)
assert result is contour_in_region(reverse_contour(contour), region)
assert result is contour_in_region(contour, reverse_contour(region))
assert result is contour_in_region(reverse_contour_coordinates(contour),
reverse_contour_coordinates(region))
def test_reversals(regions_pair: Tuple[Region, Region]) -> None:
left, right = regions_pair
result = region_in_region(left, right)
assert result is region_in_region(reverse_contour(left), right)
assert result is region_in_region(left, reverse_contour(right))
assert result is region_in_region(reverse_contour_coordinates(left),
reverse_contour_coordinates(right))
def test_reversals(contours_pair: Tuple[Contour, Contour]) -> None:
left, right = contours_pair
result = contour_in_contour(left, right)
assert result is contour_in_contour(reverse_contour(left), right)
assert result is contour_in_contour(left, reverse_contour(right))
assert result is contour_in_contour(reverse_contour_coordinates(left),
reverse_contour_coordinates(right))
def test_reversals(
context_with_contour_and_steps: Tuple[Context, Contour, Scalar, Scalar]
) -> None:
context, contour, step_x, step_y = context_with_contour_and_steps
result = context.translate_contour(contour, step_x, step_y)
assert reverse_contour(result) == context.translate_contour(
reverse_contour(contour), step_x, step_y)
assert (reverse_contour_coordinates(result) == context.translate_contour(
reverse_contour_coordinates(contour), step_y, step_x))
def test_reversals(context_with_contour: Tuple[Context, Contour]) -> None:
context, contour = context_with_contour
result = context.is_region_convex(contour)
assert result is context.is_region_convex(reverse_contour(contour))
assert result is context.is_region_convex(
reverse_contour_coordinates(contour))
def test_reversals(context_with_contour: Tuple[Context, Contour]) -> None:
context, contour = context_with_contour
result = context.region_centroid(contour)
assert result == context.region_centroid(reverse_contour(contour))
assert reverse_point_coordinates(result) == context.region_centroid(
reverse_contour_coordinates(contour))
def test_reversals(context_with_contour: Tuple[Context, Contour]) -> None:
context, contour = context_with_contour
result = context.contour_length(contour)
assert result == context.contour_length(reverse_contour(contour))
assert result == context.contour_length(
reverse_contour_coordinates(contour))
def test_reversals(contour_with_point: Tuple[Contour, Point]) -> None:
contour, point = contour_with_point
result = point_in_contour(point, contour)
assert result is point_in_contour(point, reverse_contour(contour))
assert result is point_in_contour(reverse_point_coordinates(point),
reverse_contour_coordinates(contour))
def test_reversals(region_with_point: Tuple[Region, Point]) -> None:
region, point = region_with_point
result = point_in_region(point, region)
assert result is point_in_region(point, reverse_contour(region))
assert result is point_in_region(reverse_point_coordinates(point),
reverse_contour_coordinates(region))
def test_reversals(context_with_contours: Tuple[Context, Contour]) -> None:
context, contour = context_with_contours
result = context.region_signed_area(contour)
assert result == -context.region_signed_area(reverse_contour(contour))
assert result == -context.region_signed_area(
reverse_contour_coordinates(contour))
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(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(context_with_contour_and_factors
: Tuple[Context, Contour, Scalar, Scalar]) -> None:
context, contour, factor_x, factor_y = context_with_contour_and_factors
result = context.scale_contour(contour, factor_x, factor_y)
assert (not isinstance(result, context.contour_cls)
or reverse_contour(result) == context.scale_contour(
reverse_contour(contour), factor_x, factor_y))
assert (reverse_geometry_coordinates(result)
== context.scale_contour(reverse_contour_coordinates(contour),
factor_y, factor_x))
def test_reversals(polygon_with_region: Tuple[Polygon, Region]) -> None:
polygon, region = polygon_with_region
result = region_in_polygon(region, polygon)
assert result is region_in_polygon(reverse_contour(region), polygon)
assert result is region_in_polygon(region, reverse_polygon_border(polygon))
assert result is region_in_polygon(region, reverse_polygon_holes(polygon))
assert result is region_in_polygon(region,
reverse_polygon_holes_contours(polygon))
assert result is region_in_polygon(reverse_contour_coordinates(region),
reverse_polygon_coordinates(polygon))
def test_reversals(
region_with_multisegment: Tuple[Region, Multisegment]) -> None:
region, multisegment = region_with_multisegment
result = multisegment_in_region(multisegment, region)
assert result is multisegment_in_region(reverse_multisegment(multisegment),
region)
assert result is multisegment_in_region(multisegment,
reverse_contour(region))
assert result is multisegment_in_region(
reverse_multisegment_coordinates(multisegment),
reverse_contour_coordinates(region))
def test_reversals(
contour_with_multisegment: Tuple[Contour, Multisegment]) -> None:
contour, multisegment = contour_with_multisegment
result = multisegment_in_contour(multisegment, contour)
assert result is multisegment_in_contour(
reverse_multisegment(multisegment), contour)
assert result is multisegment_in_contour(multisegment,
reverse_contour(contour))
assert result is multisegment_in_contour(
reverse_multisegment_coordinates(multisegment),
reverse_contour_coordinates(contour))
def test_reversals(polygon_with_contour: Tuple[Polygon, Contour]) -> None:
polygon, contour = polygon_with_contour
result = contour_in_polygon(contour, polygon)
assert result is contour_in_polygon(reverse_contour(contour), polygon)
assert result is contour_in_polygon(contour,
reverse_polygon_border(polygon))
assert result is contour_in_polygon(contour,
reverse_polygon_holes(polygon))
assert result is contour_in_polygon(
contour, reverse_polygon_holes_contours(polygon))
assert result is contour_in_polygon(reverse_contour_coordinates(contour),
reverse_polygon_coordinates(polygon))
def test_reversals(
multiregion_with_contour: Tuple[Multiregion, Contour]) -> None:
multiregion, contour = multiregion_with_contour
result = contour_in_multiregion(contour, multiregion)
assert result is contour_in_multiregion(reverse_contour(contour),
multiregion)
assert result is contour_in_multiregion(contour,
reverse_multiregion(multiregion))
assert result is contour_in_multiregion(
contour, reverse_multiregion_regions(multiregion))
assert result is contour_in_multiregion(
reverse_contour_coordinates(contour),
reverse_multiregion_coordinates(multiregion))
def test_reversals(
multiregion_with_region: Tuple[Multiregion, Region]) -> None:
multiregion, region = multiregion_with_region
result = region_in_multiregion(region, multiregion)
assert result is region_in_multiregion(reverse_contour(region),
multiregion)
assert result is region_in_multiregion(region,
reverse_multiregion(multiregion))
assert result is region_in_multiregion(
region, reverse_multiregion_regions(multiregion))
assert result is region_in_multiregion(
reverse_contour_coordinates(region),
reverse_multiregion_coordinates(multiregion))
def test_reversed_coordinates(contour: Contour) -> None:
result = contour_self_intersects(contour)
assert result is contour_self_intersects(
reverse_contour_coordinates(contour))
def test_reversed_coordinates(contour: Contour) -> None:
result = edges_intersect(contour)
assert result is edges_intersect(reverse_contour_coordinates(contour))
