Beispiel #1
0
def test_reversals(multisegments_pair: MultisegmentsPair) -> None:
    left_multisegment, right_multisegment = multisegments_pair

    result = intersect_multisegments(left_multisegment, right_multisegment)

    assert result == intersect_multisegments(
            reverse_multisegment(left_multisegment), right_multisegment)
    assert result == intersect_multisegments(
            left_multisegment, reverse_multisegment(right_multisegment))
Beispiel #2
0
def test_reversals(multisegments_pair: MultisegmentsPair) -> None:
    left_multisegment, right_multisegment = multisegments_pair

    result = subtract_multisegments(left_multisegment, right_multisegment)

    assert are_multisegments_similar(
        result,
        subtract_multisegments(reverse_multisegment(left_multisegment),
                               right_multisegment))
    assert result == subtract_multisegments(
        left_multisegment, reverse_multisegment(right_multisegment))
def test_reversals(
        multisegments_pair: Tuple[Multisegment, Multisegment]) -> None:
    left, right = multisegments_pair

    result = multisegment_in_multisegment(left, right)

    assert result is multisegment_in_multisegment(reverse_multisegment(left),
                                                  right)
    assert result is multisegment_in_multisegment(left,
                                                  reverse_multisegment(right))
    assert result is multisegment_in_multisegment(
        reverse_multisegment_coordinates(left),
        reverse_multisegment_coordinates(right))
Beispiel #4
0
def test_reversals(
    context_with_multisegment_and_steps: Tuple[Context, Multisegment, Scalar,
                                               Scalar]
) -> None:
    context, multisegment, step_x, step_y = context_with_multisegment_and_steps

    result = context.translate_multisegment(multisegment, step_x, step_y)

    assert reverse_multisegment(result) == context.translate_multisegment(
        reverse_multisegment(multisegment), step_x, step_y)
    assert (reverse_multisegment_coordinates(
        result) == context.translate_multisegment(
            reverse_multisegment_coordinates(multisegment), step_y, step_x))
def test_reversals(multisegments_pair: MultisegmentsPair) -> None:
    first, second = multisegments_pair

    result = subtract_multisegments(first, second)

    assert are_compounds_similar(
        result, subtract_multisegments(reverse_multisegment(first), second))
    assert result == subtract_multisegments(first,
                                            reverse_multisegment(second))
    assert are_compounds_similar(
        result,
        reverse_compound_coordinates(
            subtract_multisegments(reverse_multisegment_coordinates(first),
                                   reverse_multisegment_coordinates(second))))
def test_reversals(polygon_with_multisegment: PolygonWithMultisegment) -> None:
    polygon, multisegment = polygon_with_multisegment

    result = unite_multisegment_with_polygon(multisegment, polygon)

    assert are_compounds_similar(
        result,
        unite_multisegment_with_polygon(multisegment,
                                        reverse_polygon_border(polygon)))
    assert are_compounds_similar(
        result,
        unite_multisegment_with_polygon(multisegment,
                                        reverse_polygon_holes(polygon)))
    assert are_compounds_similar(
        result,
        unite_multisegment_with_polygon(
            multisegment, reverse_polygon_holes_contours(polygon)))
    assert are_compounds_similar(
        result,
        unite_multisegment_with_polygon(reverse_multisegment(multisegment),
                                        polygon))
    assert are_compounds_similar(
        result,
        unite_multisegment_with_polygon(
            reverse_multisegment_endpoints(multisegment), polygon))
    assert are_compounds_similar(
        result,
        reverse_compound_coordinates(
            unite_multisegment_with_polygon(
                reverse_multisegment_coordinates(multisegment),
                reverse_polygon_coordinates(polygon))))
def test_reversals(polygon_with_multisegment: PolygonWithMultisegment) -> None:
    polygon, multisegment = polygon_with_multisegment

    result = symmetric_subtract_polygon_from_multisegment(multisegment,
                                                          polygon)

    assert are_compounds_similar(
            result, symmetric_subtract_polygon_from_multisegment(
                    multisegment, reverse_polygon_border(polygon)))
    assert are_compounds_similar(
            result, symmetric_subtract_polygon_from_multisegment(
                    multisegment, reverse_polygon_holes(polygon)))
    assert are_compounds_similar(
            result, symmetric_subtract_polygon_from_multisegment(
                    multisegment, reverse_polygon_holes_contours(polygon)))
    assert are_compounds_similar(
            result, symmetric_subtract_polygon_from_multisegment(
                    reverse_multisegment(multisegment), polygon))
    assert are_compounds_similar(
            result, symmetric_subtract_polygon_from_multisegment(
                    reverse_multisegment_endpoints(multisegment), polygon))
    assert are_compounds_similar(
            result, reverse_compound_coordinates(
                    symmetric_subtract_polygon_from_multisegment(
                            reverse_multisegment_coordinates(multisegment),
                            reverse_polygon_coordinates(polygon))))
def test_reversals(
        context_with_multisegment: Tuple[Context, Multisegment]) -> None:
    context, multisegment = context_with_multisegment

    result = context.multisegment_length(multisegment)

    assert result == context.multisegment_length(
        reverse_multisegment(multisegment))
    assert result == context.multisegment_length(
        reverse_multisegment_coordinates(multisegment))
def test_reversals(multisegment_with_point: Tuple[Multisegment, Point]
                   ) -> None:
    multisegment, point = multisegment_with_point

    result = point_in_multisegment(point, multisegment)

    assert result is point_in_multisegment(point,
                                           reverse_multisegment(multisegment))
    assert result is point_in_multisegment(
            reverse_point_coordinates(point),
            reverse_multisegment_coordinates(multisegment))
Beispiel #10
0
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))
Beispiel #12
0
def test_reversals(
    context_with_multisegment_and_factors: Tuple[Context, Multisegment, Scalar,
                                                 Scalar]
) -> None:
    (context, multisegment, factor_x,
     factor_y) = context_with_multisegment_and_factors

    result = context.scale_multisegment(multisegment, factor_x, factor_y)

    assert reverse_geometry(result) == context.scale_multisegment(
        reverse_multisegment(multisegment), factor_x, factor_y)
    assert (reverse_geometry_coordinates(result) == context.scale_multisegment(
        reverse_multisegment_coordinates(multisegment), 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(
        multiregion_with_multisegment: Tuple[Multiregion,
                                             Multisegment]) -> None:
    multiregion, multisegment = multiregion_with_multisegment

    result = multisegment_in_multiregion(multisegment, multiregion)

    assert result is multisegment_in_multiregion(
        reverse_multisegment(multisegment), multiregion)
    assert result is multisegment_in_multiregion(
        multisegment, reverse_multiregion(multiregion))
    assert result is multisegment_in_multiregion(
        multisegment, reverse_multiregion_regions(multiregion))
    assert result is multisegment_in_multiregion(
        reverse_multisegment_coordinates(multisegment),
        reverse_multiregion_coordinates(multiregion))
Beispiel #15
0
def test_reversals(
        polygon_with_multisegment: Tuple[Polygon, Multisegment]) -> None:
    polygon, multisegment = polygon_with_multisegment

    result = multisegment_in_polygon(multisegment, polygon)

    assert result is multisegment_in_polygon(
        reverse_multisegment(multisegment), polygon)
    assert result is multisegment_in_polygon(multisegment,
                                             reverse_polygon_border(polygon))
    assert result is multisegment_in_polygon(multisegment,
                                             reverse_polygon_holes(polygon))
    assert result is multisegment_in_polygon(
        multisegment, reverse_polygon_holes_contours(polygon))
    assert result is multisegment_in_polygon(
        reverse_multisegment_coordinates(multisegment),
        reverse_polygon_coordinates(polygon))
Beispiel #16
0
def test_reversals(
        multipolygon_with_multisegment: MultipolygonWithMultisegment) -> None:
    multipolygon, multisegment = multipolygon_with_multisegment

    result = complete_intersect_multisegment_with_multipolygon(
        multisegment, multipolygon)

    assert result == complete_intersect_multisegment_with_multipolygon(
        multisegment, reverse_multipolygon(multipolygon))
    assert result == complete_intersect_multisegment_with_multipolygon(
        multisegment, reverse_multipolygon_borders(multipolygon))
    assert result == complete_intersect_multisegment_with_multipolygon(
        multisegment, reverse_multipolygon_holes(multipolygon))
    assert result == complete_intersect_multisegment_with_multipolygon(
        multisegment, reverse_multipolygon_holes_contours(multipolygon))
    assert result == complete_intersect_multisegment_with_multipolygon(
        reverse_multisegment(multisegment), multipolygon)
    assert result == complete_intersect_multisegment_with_multipolygon(
        reverse_multisegment_endpoints(multisegment), multipolygon)
Beispiel #17
0
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))))
Beispiel #18
0
def test_reversals(
        multipolygon_with_multisegment: MultipolygonWithMultisegment) -> None:
    multipolygon, multisegment = multipolygon_with_multisegment

    result = subtract_multipolygon_from_multisegment(multisegment,
                                                     multipolygon)

    assert result == subtract_multipolygon_from_multisegment(
        multisegment, reverse_multipolygon(multipolygon))
    assert result == subtract_multipolygon_from_multisegment(
        multisegment, reverse_multipolygon_borders(multipolygon))
    assert result == subtract_multipolygon_from_multisegment(
        multisegment, reverse_multipolygon_holes(multipolygon))
    assert result == subtract_multipolygon_from_multisegment(
        multisegment, reverse_multipolygon_holes_contours(multipolygon))
    assert are_multisegments_similar(
        result,
        subtract_multipolygon_from_multisegment(
            reverse_multisegment(multisegment), multipolygon))
    assert are_multisegments_similar(
        result,
        subtract_multipolygon_from_multisegment(
            reverse_multisegment_endpoints(multisegment), multipolygon))
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))))
Beispiel #20
0
def test_reversals(multisegment: Multisegment) -> None:
    assert multisegment == reverse_multisegment(multisegment)
    assert multisegment == reverse_multisegment_segments(multisegment)
Beispiel #21
0
def test_reversals(multisegment: Multisegment) -> None:
    assert hash(multisegment) == hash(reverse_multisegment(multisegment))