コード例 #1
0
def test_reversals(multisegments_pair: MultisegmentsPair) -> None:
    first, second = multisegments_pair

    result = intersect_multisegments(first, second)

    assert result == intersect_multisegments(
            first, reverse_multisegment(second))
    assert are_compounds_similar(
            result, reverse_compound_coordinates(intersect_multisegments(
                    reverse_multisegment_coordinates(first),
                    reverse_multisegment_coordinates(second))))
コード例 #2
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))
コード例 #3
0
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))
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))))
コード例 #5
0
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))))
コード例 #6
0
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))
コード例 #7
0
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))
コード例 #8
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))
コード例 #9
0
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))
コード例 #10
0
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))
コード例 #11
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))
コード例 #12
0
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))
コード例 #13
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))
コード例 #14
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))))
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))))