Esempio n. 1
0
def shaped_to_invalid_mix(shaped: Shaped) -> Strategy[Mix]:
    polygons = shaped_to_polygons(shaped)
    vertices = list(
        flatten(
            chain(polygon.border.vertices,
                  flatten(hole.vertices for hole in polygon.holes))
            for polygon in polygons))
    edges = list(flatten(polygon.edges for polygon in polygons))
    scales = strategies.integers(2, 100)
    rational_edges = strategies.sampled_from(edges).map(to_rational_segment)
    return (strategies.builds(Mix,
                              sub_lists(vertices, min_size=2).map(Multipoint),
                              empty_geometries, strategies.just(shaped))
            | strategies.builds(
                Mix, empty_geometries,
                strategies.builds(stretch_segment_end, rational_edges, scales),
                strategies.just(shaped))
            | strategies.builds(
                Mix, empty_geometries,
                strategies.builds(stretch_segment_start, rational_edges,
                                  scales), strategies.just(shaped))
            | strategies.builds(
                Mix, empty_geometries,
                strategies.sampled_from(polygons).map(to_polygon_diagonals),
                strategies.just(shaped))
            | strategies.builds(Mix, empty_geometries,
                                sub_lists(edges, min_size=2).map(Multisegment),
                                strategies.just(shaped)))
Esempio n. 2
0
def to_polygons_with_extra_points(
        polygon: Polygon) -> Strategy[Tuple[Polygon, Sequence[Point]]]:
    return strategies.tuples(
        strategies.just(polygon),
        sub_lists(
            sum(map(contour_to_edges, polygon.holes),
                contour_to_edges(polygon.border))).flatmap(to_segments_points))
Esempio n. 3
0
def multipolygon_to_multipolygons_with_multisegments(
        multipolygon: Multipolygon,
        *,
        min_size: int = 2) -> Strategy[Tuple[Multipolygon, Multisegment]]:
    edges = list(to_multipolygon_edges(multipolygon))
    return strategies.tuples(strategies.just(multipolygon),
                             sub_lists(edges,
                                       min_size=min_size)
                             .map(Multisegment))
Esempio n. 4
0
def polygon_to_polygons_with_multisegments(polygon: Polygon,
                                           *,
                                           min_size: int = 2
                                           ) -> Strategy[Tuple[Polygon,
                                                               Multisegment]]:
    return strategies.tuples(strategies.just(polygon),
                             sub_lists(list(to_polygon_edges(polygon)),
                                       min_size=min_size)
                             .map(Multisegment))
Esempio n. 5
0
def contour_to_invalid_polygons(convex_contour: Contour) -> Strategy[Polygon]:
    return strategies.builds(
        Polygon, strategies.just(convex_contour),
        sub_lists(convex_contour.vertices, min_size=3).map(Contour).map(lift))
Esempio n. 6
0
 def to_contexts_with_segments_subsets(segments: Sequence[Segment]
                                       ) -> Strategy[Sequence[Segment]]:
     return sub_lists(segments,
                      min_size=2)