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)
from hypothesis import strategies
from gon.base import (EMPTY, Mix, Multipoint, Multisegment, Segment, Shaped)
from gon.hints import Scalar
from tests.strategies import (
coordinates_strategies, coordinates_to_linear_geometries,
coordinates_to_mixes, coordinates_to_multipoints, coordinates_to_points,
coordinates_to_shaped_geometries, invalid_linear_geometries,
invalid_multipoints, invalid_shaped_geometries)
from tests.utils import (Strategy, cleave_in_tuples, flatten,
shaped_to_polygons, sub_lists, to_pairs,
to_polygon_diagonals, to_rational_segment,
to_triplets)
mixes = coordinates_strategies.flatmap(coordinates_to_mixes)
empty_geometries = strategies.just(EMPTY)
multipoints = coordinates_strategies.flatmap(coordinates_to_multipoints)
linear_geometries = (
coordinates_strategies.flatmap(coordinates_to_linear_geometries))
shaped_geometries = (
coordinates_strategies.flatmap(coordinates_to_shaped_geometries))
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))
from hypothesis import strategies
from gon.base import EMPTY
from tests.strategies import (coordinates_strategies, coordinates_to_points)
empty_geometries = strategies.just(EMPTY)
empty_geometries_with_points = strategies.tuples(
empty_geometries, coordinates_strategies.flatmap(coordinates_to_points))
from typing import Tuple
from hypothesis import strategies
from seidel.hints import Coordinate
from seidel.point import Point
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_points, to_pairs,
to_triplets)
from tests.utils import Strategy
coordinates_pairs = coordinates_strategies.flatmap(to_pairs)
points = coordinates_strategies.flatmap(coordinates_to_ported_points)
def coordinates_to_points_with_origins(
coordinates: Strategy[Coordinate]) -> Strategy[Tuple[Point, Point]]:
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 = (
from hypothesis import strategies
from gon.hints import Scalar
from tests.strategies import (coordinates_strategies, coordinates_to_points,
coordinates_to_shaped_geometries,
rational_coordinates_strategies,
rational_cosines_sines)
from tests.utils import (Strategy, cleave_in_tuples, identity)
rational_shaped_geometries = (
rational_coordinates_strategies.flatmap(coordinates_to_shaped_geometries))
shaped_geometries = (
coordinates_strategies.flatmap(coordinates_to_shaped_geometries))
rational_shaped_geometries_with_coordinates_pairs = (
rational_coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_shaped_geometries, identity,
identity)))
def coordinates_to_non_zero_coordinates(
coordinates: Strategy[Scalar]) -> Strategy[Scalar]:
return coordinates.filter(bool)
rational_shaped_geometries_with_non_zero_coordinates_pairs = (
rational_coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_shaped_geometries,
coordinates_to_non_zero_coordinates,
coordinates_to_non_zero_coordinates)))
rational_shaped_geometries_points_with_cosines_sines = (strategies.tuples(
(rational_coordinates_strategies.flatmap(
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_edges_with_nodes_pairs,
coordinates_to_ported_y_nodes, to_pairs,
to_triplets)
edges_with_nodes_pairs = coordinates_strategies.flatmap(
coordinates_to_ported_edges_with_nodes_pairs)
y_nodes = coordinates_strategies.flatmap(coordinates_to_ported_y_nodes)
y_nodes_strategies = coordinates_strategies.map(coordinates_to_ported_y_nodes)
y_nodes_pairs = y_nodes_strategies.flatmap(to_pairs)
y_nodes_triplets = y_nodes_strategies.flatmap(to_triplets)
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(
sum(map(contour_to_segments, holes),
contour_to_segments(border))).flatmap(to_segments_points))
def to_segments_points(
from tests.strategies import (coordinates_strategies,
coordinates_to_ported_points_pairs_edges_pairs,
coordinates_to_ported_trapezoids,
to_pairs,
to_triplets)
points_pairs_edges_pairs = coordinates_strategies.flatmap(
coordinates_to_ported_points_pairs_edges_pairs)
trapezoids = coordinates_strategies.flatmap(coordinates_to_ported_trapezoids)
trapezoids_strategies = (coordinates_strategies
.map(coordinates_to_ported_trapezoids))
trapezoids_pairs = trapezoids_strategies.flatmap(to_pairs)
trapezoids_triplets = trapezoids_strategies.flatmap(to_triplets)
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)
def coordinates_to_bounding_boxes_with_points(
coordinates: Strategy[Coordinate]
) -> Strategy[Tuple[BoundingBox, Point]]:
return strategies.tuples(coordinates_to_bounding_boxes(coordinates),
coordinates_to_ported_points(coordinates))
bounding_boxes_with_points = coordinates_strategies.flatmap(
coordinates_to_bounding_boxes_with_points)
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 hypothesis import strategies
from tests.strategies import (coordinates_strategies,
coordinates_to_linear_geometries,
coordinates_to_points,
rational_coordinates_strategies,
rational_cosines_sines)
from tests.utils import (cleave_in_tuples, identity)
linear_geometries = coordinates_strategies.flatmap(
coordinates_to_linear_geometries)
rational_linear_geometries_with_coordinates_pairs = (
rational_coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_linear_geometries, identity,
identity)))
rational_linear_geometries_points_with_cosines_sines = (strategies.tuples(
(rational_coordinates_strategies.flatmap(
cleave_in_tuples(coordinates_to_linear_geometries,
coordinates_to_points))), rational_cosines_sines))
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)
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
from tests.strategies.base import MAX_COORDINATE
from tests.utils import (Point, Polygon, Segment, Strategy, contour_to_edges,
points_do_not_lie_on_the_same_line,
segment_contains_point, sub_lists)
contexts = strategies.just(get_context())
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)).filter(points_do_not_lie_on_the_same_line))
triangles = coordinates_strategies.flatmap(planar.triangular_contours)
polygons = coordinates_strategies.flatmap(planar.polygons)
whole_polygons = coordinates_strategies.flatmap(
partial(planar.polygons, max_holes_size=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))
def to_segments_points(
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 functools import partial
from typing import Tuple
from ground.base import get_context
from ground.hints import Scalar
from hypothesis import strategies
from hypothesis_geometry import planar
from tests.strategies import coordinates_strategies
from tests.utils import (Multisegment, Point, Polygon, Strategy)
contexts = strategies.just(get_context())
multisegments = coordinates_strategies.flatmap(planar.multisegments)
def to_multisegments_with_points(
coordinates: Strategy[Scalar]) -> Strategy[Tuple[Multisegment, Point]]:
return strategies.tuples(planar.multisegments(coordinates),
planar.points(coordinates))
multisegments_with_points = (
coordinates_strategies.flatmap(to_multisegments_with_points))
polygons = coordinates_strategies.flatmap(planar.polygons)
def to_polygons_with_points(
coordinates: Strategy[Scalar]) -> Strategy[Tuple[Polygon, Point]]:
return strategies.tuples(planar.polygons(coordinates),
planar.points(coordinates))
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)))
return (strategies.lists(points, min_size=2, max_size=8,
unique=True).map(to_net))
rational_segments_lists = ((rational_coordinates_strategies.map(
planar.segments).flatmap(strategies.lists))
| (rational_coordinates_strategies.map(
planar.points).flatmap(points_to_nets)))
segments_lists = (
(coordinates_strategies.map(planar.segments).flatmap(strategies.lists))
| (coordinates_strategies.map(planar.points).flatmap(points_to_nets)))
empty_multipolygons = strategies.builds(Multipolygon, strategies.builds(list))
empty_multiregions = strategies.builds(list)
empty_multisegments = strategies.builds(Multisegment, strategies.builds(list))
multipolygons = coordinates_strategies.flatmap(planar.multipolygons)
multiregions = coordinates_strategies.flatmap(planar.multicontours)
multisegments = coordinates_strategies.flatmap(planar.multisegments)
empty_multisegments_with_multisegments = strategies.tuples(
empty_multisegments, multisegments)
rational_multisegments_strategies = (rational_coordinates_strategies.map(
planar.multisegments))
rational_multisegments_pairs = (
rational_multisegments_strategies.flatmap(to_pairs))
rational_multisegments_triplets = (
rational_multisegments_strategies.flatmap(to_triplets))
multisegments_strategies = coordinates_strategies.map(planar.multisegments)
multisegments_pairs = multisegments_strategies.flatmap(to_pairs)
multisegments_triplets = multisegments_strategies.flatmap(to_triplets)
empty_multipolygons_with_multisegments = strategies.tuples(
empty_multipolygons, multisegments)
coordinates_to_multisegments, coordinates_to_contours,
coordinates_to_polygons, coordinates_to_multipolygons, coordinates_to_mixes
]))
non_empty_geometries_factories = (strategies.just(coordinates_to_points)
| non_empty_compounds_factories)
geometries_factories = (strategies.just(empty_compounds_factory)
| non_empty_geometries_factories)
geometries_strategies = strategies.builds(call, geometries_factories,
coordinates_strategies)
geometries = geometries_strategies.flatmap(identity)
rational_geometries_with_non_zero_coordinates_pairs = strategies.builds(
call,
geometries_factories.map(lambda factory: cleave_in_tuples(
factory, to_non_zero_coordinates, to_non_zero_coordinates)),
rational_coordinates_strategies).flatmap(identity)
empty_compounds_with_coordinates_pairs = (coordinates_strategies.flatmap(
cleave_in_tuples(empty_compounds_factory, identity, identity)))
geometries_with_coordinates_pairs = strategies.builds(
call,
geometries_factories.map(lambda factory: cleave_in_tuples(
factory, to_zero_coordinates, identity))
| geometries_factories.map(lambda factory: cleave_in_tuples(
factory, identity, to_zero_coordinates))
| geometries_factories.map(
lambda factory: cleave_in_tuples(factory, identity, identity)),
coordinates_strategies).flatmap(identity)
rational_geometries_with_points = ((strategies.builds(
call,
geometries_factories.map(
lambda factory: cleave_in_tuples(factory, coordinates_to_points)),
rational_coordinates_strategies).flatmap(identity)))
rational_geometries_points_with_cosines_sines = strategies.tuples(
from tests.utils import (Multipolygon,
Multisegment,
Point,
Polygon,
Segment,
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)
