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)