return strategies.tuples(coordinates_to_ported_points(coordinates),
coordinates_to_origins(coordinates))
def coordinates_to_origins(
coordinates: Strategy[Coordinate]) -> Strategy[Point]:
def coordinate_to_origin(coordinate: Coordinate) -> Point:
domain = type(coordinate)
return Point(domain(), domain())
return coordinates.map(coordinate_to_origin)
points_with_origins = (
coordinates_strategies.flatmap(coordinates_to_points_with_origins))
def coordinates_to_points_pairs_with_origins(
coordinates: Strategy[Coordinate]
) -> Strategy[Tuple[Point, Point, Point]]:
points = coordinates_to_ported_points(coordinates)
return strategies.tuples(points, points,
coordinates_to_origins(coordinates))
points_pairs_with_origins = coordinates_strategies.flatmap(
coordinates_to_points_pairs_with_origins)
points_strategies = coordinates_strategies.map(coordinates_to_ported_points)
points_pairs = points_strategies.flatmap(to_pairs)
points_triplets = points_strategies.flatmap(to_triplets)
from typing import (Sequence, Tuple)
from hypothesis import strategies
from hypothesis_geometry import planar
from robust.linear import segment_contains
from sect.core.utils import contour_to_segments
from sect.hints import (Point, Segment)
from tests.strategies import coordinates_strategies
from tests.strategies.base import MAX_COORDINATE
from tests.utils import (Polygon, Strategy, points_do_not_lie_on_the_same_line,
sub_lists)
to_points_lists = partial(strategies.lists, unique=True)
points_lists = (coordinates_strategies.map(planar.points).flatmap(
partial(to_points_lists,
min_size=3)).filter(points_do_not_lie_on_the_same_line))
non_triangle_points_lists = (coordinates_strategies.map(planar.points).flatmap(
partial(to_points_lists, min_size=4)))
triangles = (coordinates_strategies.flatmap(
planar.triangular_contours).map(tuple))
contours = coordinates_strategies.flatmap(planar.contours)
polygons = coordinates_strategies.flatmap(planar.polygons)
def to_polygons_with_extra_points(
polygon: Polygon) -> Strategy[Tuple[Polygon, Sequence[Point]]]:
border, holes = polygon
return strategies.tuples(
strategies.just(polygon),
sub_lists(
from itertools import combinations
from typing import List
from ground.hints import Scalar
from hypothesis import strategies
from hypothesis_geometry import planar
from tests.strategies import coordinates_strategies
from tests.utils import (MultisegmentWithSegment, Point,
PolygonWithMultisegment, PolygonWithSegment, Segment,
Strategy, to_pairs, to_triplets)
segments_strategies = coordinates_strategies.map(planar.segments)
segments = coordinates_strategies.flatmap(planar.segments)
segments_pairs = segments_strategies.flatmap(to_pairs)
segments_triplets = segments_strategies.flatmap(to_triplets)
def points_to_nets(points: Strategy[Point]) -> Strategy[List[Segment]]:
def to_net(points_list: List[Point]) -> List[Segment]:
return [
Segment(start, end) for start, end in combinations(points_list, 2)
]
return (strategies.lists(points, min_size=2, max_size=8,
unique=True).map(to_net))
segments_lists = (
(coordinates_strategies.map(planar.segments).flatmap(strategies.lists))
| (coordinates_strategies.map(planar.points).flatmap(points_to_nets)))
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_leaves,
coordinates_to_ported_trapezoids, to_pairs,
to_triplets)
trapezoids = coordinates_strategies.flatmap(coordinates_to_ported_trapezoids)
leaves = coordinates_strategies.flatmap(coordinates_to_ported_leaves)
leaves_strategies = coordinates_strategies.map(coordinates_to_ported_leaves)
leaves_pairs = leaves_strategies.flatmap(to_pairs)
leaves_triplets = leaves_strategies.flatmap(to_triplets)
from tests.strategies import (coordinates_strategies,
coordinates_to_multipolygons,
coordinates_to_points, coordinates_to_polygons,
invalid_multipolygons)
from tests.utils import (cleave_in_tuples, to_pairs, to_triplets)
multipolygons = coordinates_strategies.flatmap(coordinates_to_multipolygons)
polygons = coordinates_strategies.flatmap(coordinates_to_polygons)
invalid_multipolygons = invalid_multipolygons
multipolygons_strategies = (
coordinates_strategies.map(coordinates_to_multipolygons))
multipolygons_pairs = multipolygons_strategies.flatmap(to_pairs)
multipolygons_triplets = multipolygons_strategies.flatmap(to_triplets)
multipolygons_with_points = (coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_multipolygons, coordinates_to_points)))
from tests.strategies import (coordinates_strategies, coordinates_to_points,
coordinates_to_segments, invalid_segments,
rational_coordinates_strategies)
from tests.utils import (cleave_in_tuples, to_pairs, to_triplets)
rational_segments = (
rational_coordinates_strategies.flatmap(coordinates_to_segments))
segments = coordinates_strategies.flatmap(coordinates_to_segments)
invalid_segments = invalid_segments
segments_strategies = coordinates_strategies.map(coordinates_to_segments)
segments_with_points = (coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_segments, coordinates_to_points)))
segments_pairs = segments_strategies.flatmap(to_pairs)
segments_triplets = segments_strategies.flatmap(to_triplets)
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_points_with_nodes_pairs,
coordinates_to_ported_x_nodes, to_pairs,
to_triplets)
points_with_nodes_pairs = coordinates_strategies.flatmap(
coordinates_to_ported_points_with_nodes_pairs)
x_nodes = coordinates_strategies.flatmap(coordinates_to_ported_x_nodes)
x_nodes_strategies = coordinates_strategies.map(coordinates_to_ported_x_nodes)
x_nodes_pairs = x_nodes_strategies.flatmap(to_pairs)
x_nodes_triplets = x_nodes_strategies.flatmap(to_triplets)
segment.start.translate(scale * (segment.start.x - segment.end.x),
scale * (segment.start.y - segment.end.y)),
segment.end)
invalid_mixes = (
shaped_geometries.flatmap(shaped_to_invalid_mix)
| strategies.builds(Mix, empty_geometries | multipoints, empty_geometries,
empty_geometries)
| strategies.builds(Mix, empty_geometries,
empty_geometries | linear_geometries, empty_geometries)
| strategies.builds(Mix, empty_geometries, empty_geometries,
empty_geometries | shaped_geometries)
| strategies.builds(Mix, invalid_multipoints, empty_geometries
| linear_geometries, shaped_geometries)
| strategies.builds(Mix, invalid_multipoints, linear_geometries,
empty_geometries | shaped_geometries)
| strategies.builds(Mix, empty_geometries | multipoints,
invalid_linear_geometries, shaped_geometries)
| strategies.builds(Mix, multipoints, invalid_linear_geometries,
empty_geometries | shaped_geometries)
| strategies.builds(Mix, multipoints, empty_geometries | linear_geometries,
invalid_shaped_geometries)
| strategies.builds(Mix, empty_geometries | multipoints, linear_geometries,
invalid_shaped_geometries))
mixes_with_points = (coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_mixes, coordinates_to_points)))
mixes_strategies = coordinates_strategies.map(coordinates_to_mixes)
mixes_pairs = mixes_strategies.flatmap(to_pairs)
mixes_triplets = mixes_strategies.flatmap(to_triplets)
from tests.strategies import (coordinates_strategies, coordinates_to_points,
coordinates_to_polygons, invalid_polygons,
rational_coordinates_strategies)
from tests.utils import (cleave_in_tuples, to_pairs, to_triplets)
rational_polygons = (
rational_coordinates_strategies.flatmap(coordinates_to_polygons))
polygons = coordinates_strategies.flatmap(coordinates_to_polygons)
invalid_polygons = invalid_polygons
polygons_strategies = coordinates_strategies.map(coordinates_to_polygons)
polygons_pairs = polygons_strategies.flatmap(to_pairs)
polygons_triplets = polygons_strategies.flatmap(to_triplets)
polygons_with_points = (coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_polygons, coordinates_to_points)))
from tests.strategies import (coordinates_strategies,
coordinates_to_multipoints,
coordinates_to_points, invalid_multipoints)
from tests.utils import (cleave_in_tuples, to_pairs, to_triplets)
multipoints = coordinates_strategies.flatmap(coordinates_to_multipoints)
invalid_multipoints = invalid_multipoints
multipoints_with_points = (coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_multipoints, coordinates_to_points)))
multipoints_strategies = coordinates_strategies.map(coordinates_to_multipoints)
multipoints_pairs = multipoints_strategies.flatmap(to_pairs)
multipoints_triplets = multipoints_strategies.flatmap(to_triplets)
from typing import Tuple
from hypothesis import strategies
from seidel.bounding_box import BoundingBox
from seidel.hints import Coordinate
from seidel.point import Point
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_points, to_pairs)
from tests.utils import Strategy
booleans = strategies.booleans()
points_pairs = (
coordinates_strategies.map(coordinates_to_ported_points).flatmap(to_pairs))
def coordinates_to_bounding_boxes(
coordinates: Strategy[Coordinate]) -> Strategy[BoundingBox]:
def to_bounding_box(empty: bool, first_x: Coordinate, first_y: Coordinate,
second_x: Coordinate,
second_y: Coordinate) -> BoundingBox:
left_x, right_x = sorted((first_x, second_x))
lower_y, upper_y = sorted((first_y, second_y))
return BoundingBox(empty, Point(left_x, lower_y),
Point(right_x, upper_y))
return strategies.builds(to_bounding_box, booleans, coordinates,
coordinates, coordinates, coordinates)
bounding_boxes = coordinates_strategies.flatmap(coordinates_to_bounding_boxes)
from typing import Tuple
from hypothesis import strategies
from seidel.edge import Edge
from seidel.hints import Coordinate
from seidel.point import Point
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_edges,
coordinates_to_ported_points,
coordinates_to_sorted_ported_points_pairs,
to_pairs, to_triplets)
from tests.utils import Strategy
sorted_points_pairs = (
coordinates_strategies.flatmap(coordinates_to_sorted_ported_points_pairs))
edges = coordinates_strategies.flatmap(coordinates_to_ported_edges)
def coordinates_to_edges_with_points(
coordinates: Strategy[Coordinate]) -> Strategy[Tuple[Edge, Point]]:
return strategies.tuples(coordinates_to_ported_edges(coordinates),
coordinates_to_ported_points(coordinates))
edges_with_points = (
coordinates_strategies.flatmap(coordinates_to_edges_with_points))
edges_strategies = coordinates_strategies.map(coordinates_to_ported_edges)
edges_pairs = edges_strategies.flatmap(to_pairs)
edges_triplets = edges_strategies.flatmap(to_triplets)
from typing import Tuple
from hypothesis import strategies
from gon.base import (Contour, Point)
from gon.hints import Scalar
from tests.strategies import (coordinates_strategies, coordinates_to_contours,
coordinates_to_points, invalid_contours,
to_non_zero_coordinates, to_zero_coordinates)
from tests.utils import (Strategy, cleave_in_tuples, to_pairs, to_triplets)
contours = coordinates_strategies.flatmap(coordinates_to_contours)
def coordinates_to_contours_with_points(
coordinates: Strategy[Scalar]) -> Strategy[Tuple[Contour, Point]]:
return strategies.tuples(coordinates_to_contours(coordinates),
coordinates_to_points(coordinates))
contours_with_points = (
coordinates_strategies.flatmap(coordinates_to_contours_with_points))
invalid_contours = invalid_contours
contours_with_zero_non_zero_coordinates = coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_contours, to_zero_coordinates,
to_non_zero_coordinates))
contours_strategies = coordinates_strategies.map(coordinates_to_contours)
contours_pairs = contours_strategies.flatmap(to_pairs)
contours_triplets = contours_strategies.flatmap(to_triplets)
Strategy,
cleave_in_tuples,
left_scale_segment,
right_scale_segment,
sub_lists,
to_multipolygon_edges,
to_pairs,
to_polygon_edges,
to_triplets)
points = coordinates_strategies.flatmap(planar.points)
segments = coordinates_strategies.flatmap(planar.segments)
segments_with_points = (coordinates_strategies
.flatmap(cleave_in_tuples(planar.segments,
planar.points)))
segments_strategies = coordinates_strategies.map(planar.segments)
segments_pairs = segments_strategies.flatmap(to_pairs)
multisegments = coordinates_strategies.flatmap(planar.multisegments)
multisegments_with_points = (coordinates_strategies
.flatmap(cleave_in_tuples(planar.multisegments,
planar.points)))
multisegments_with_segments = (coordinates_strategies
.flatmap(cleave_in_tuples(planar.multisegments,
planar.segments)))
to_size_three_or_more_multisegments = partial(planar.multisegments,
min_size=3)
size_three_or_more_multisegments_with_segments = (
(coordinates_strategies
.flatmap(cleave_in_tuples(to_size_three_or_more_multisegments,
planar.segments))))
