def test_invalid_sizes(coordinates: Strategy[Scalar],
invalid_sizes_pair: SizesPair) -> None:
min_size, max_size = invalid_sizes_pair
with pytest.raises(ValueError):
contours(coordinates,
min_size=min_size,
max_size=max_size)
def test_non_valid_sizes(coordinates: Strategy[Scalar],
non_valid_sizes_pair: SizesPair) -> None:
min_size, max_size = non_valid_sizes_pair
with pytest.warns(HypothesisWarning) as warnings:
contours(coordinates,
min_size=min_size,
max_size=max_size)
assert len(warnings) == 1
def test_same_coordinates(data: DataObject,
coordinates_limits_type: ScalarsLimitsType,
sizes_pair: SizesPair) -> None:
(coordinates, (min_value, max_value)), type_ = coordinates_limits_type
min_size, max_size = sizes_pair
strategy = contours(coordinates,
min_size=min_size,
max_size=max_size)
result = data.draw(strategy)
assert is_contour(result)
assert contour_has_valid_sizes(result,
min_size=min_size,
max_size=max_size)
assert contour_has_coordinates_types(result,
x_type=type_,
y_type=type_)
assert contour_has_coordinates_in_range(result,
min_x_value=min_value,
max_x_value=max_value,
min_y_value=min_value,
max_y_value=max_value)
assert are_vertices_strict(result.vertices)
assert is_contour_non_self_intersecting(result)
assert is_contour_counterclockwise(result)
def test_properties(data: DataObject,
coordinates_limits_type_pair: Tuple[ScalarsLimitsType,
ScalarsLimitsType],
sizes_pair: SizesPair) -> None:
(x_coordinates_limits_type,
y_coordinates_limits_type) = coordinates_limits_type_pair
((x_coordinates, (min_x_value, max_x_value)),
x_type) = x_coordinates_limits_type
((y_coordinates, (min_y_value, max_y_value)),
y_type) = y_coordinates_limits_type
min_size, max_size = sizes_pair
strategy = contours(x_coordinates, y_coordinates,
min_size=min_size,
max_size=max_size)
result = data.draw(strategy)
assert is_contour(result)
assert contour_has_valid_sizes(result,
min_size=min_size,
max_size=max_size)
assert contour_has_coordinates_types(result,
x_type=x_type,
y_type=y_type)
assert contour_has_coordinates_in_range(result,
min_x_value=min_x_value,
max_x_value=max_x_value,
min_y_value=min_y_value,
max_y_value=max_y_value)
assert is_contour_strict(result)
assert is_contour_non_self_intersecting(result)
assert is_contour_counterclockwise(result)
def test_basic(coordinates: Strategy[Scalar],
sizes_pair: SizesPair) -> None:
min_size, max_size = sizes_pair
result = contours(coordinates,
min_size=min_size,
max_size=max_size)
assert isinstance(result, Strategy)
from hypothesis import strategies
from hypothesis_geometry import planar
from tests.binding_tests.utils import (bound_fill_kinds, bound_polygon_kinds)
from tests.integration_tests.utils import (
to_bound_with_ported_linear_rings_pair,
to_bound_with_ported_multipolygons_pair,
to_bound_with_ported_points_lists_pair, to_bound_with_ported_polygons_pair,
to_bound_with_ported_wagyus_pair)
from tests.port_tests.utils import (ported_fill_kinds, ported_polygon_kinds)
from tests.strategies import coordinates
booleans = strategies.booleans()
wagyus_pairs = strategies.builds(to_bound_with_ported_wagyus_pair, booleans)
linear_rings_points_pairs = (
planar.contours(coordinates).map(to_bound_with_ported_points_lists_pair))
linear_rings_pairs = (
linear_rings_points_pairs.map(to_bound_with_ported_linear_rings_pair))
polygons_pairs = (
planar.polygons(coordinates).map(to_bound_with_ported_polygons_pair))
polygon_kinds_pairs = strategies.sampled_from(
list(zip(bound_polygon_kinds, ported_polygon_kinds)))
multipolygons_pairs = (planar.multipolygons(coordinates).map(
to_bound_with_ported_multipolygons_pair))
fill_kinds_pairs = strategies.sampled_from(
list(zip(bound_fill_kinds, ported_fill_kinds)))
from typing import (List, Tuple)
from hypothesis import strategies
from hypothesis_geometry import planar
from tests.port_tests.utils import (ported_polygon_kinds,
to_ported_linear_rings_points,
to_ported_polygon_linear_rings)
from tests.strategies import coordinates
from tests.utils import Strategy
from wagyu.enums import PolygonKind
from wagyu.linear_ring import LinearRing
from wagyu.local_minimum import LocalMinimumList
linear_rings_points = (
planar.contours(coordinates).map(to_ported_linear_rings_points))
linear_rings = strategies.builds(LinearRing, linear_rings_points)
polygon_kinds = strategies.sampled_from(ported_polygon_kinds)
linear_rings_lists = (
planar.polygons(coordinates).map(to_ported_polygon_linear_rings))
empty_local_minimum_lists = strategies.builds(LocalMinimumList)
def to_local_minimum_list(
linear_rings_with_polygon_kinds: List[Tuple[LinearRing, PolygonKind]]
) -> LocalMinimumList:
result = LocalMinimumList()
for linear_ring, polygon_kind in linear_rings_with_polygon_kinds:
result.add_linear_ring(linear_ring, polygon_kind)
return result
from _wagyu import (LinearRing, Polygon, Wagyu)
from hypothesis import strategies
from hypothesis_geometry import planar
from tests.binding_tests.utils import (bound_polygon_kinds,
to_bound_points_list,
to_bound_polygon_linear_rings)
from tests.strategies import coordinates
polygon_kinds = strategies.sampled_from(bound_polygon_kinds)
linear_rings_points = planar.contours(coordinates).map(to_bound_points_list)
linear_rings = strategies.builds(LinearRing, linear_rings_points)
linear_rings_lists = (
planar.polygons(coordinates).map(to_bound_polygon_linear_rings))
polygons = strategies.builds(Polygon, linear_rings_lists)
empty_wagyus = strategies.builds(Wagyu)
from sect.triangulation import constrained_delaunay_triangles
from tests.pode_tests.config import (MAX_CONTOUR_SIZE, MAX_COORDINATE,
MAX_HOLES_SIZE, MIN_CONTOUR_SIZE,
MIN_COORDINATE, MIN_HOLES_SIZE)
from pode.utils import joined_constrained_delaunay_triangles
T = TypeVar('T')
TRIANGULAR_CONTOUR_SIZE = 3
RECTANGLE_CONTOUR_SIZE = 4
MIN_PARTITION_SIZE = 1
nonnegative_integers = st.integers(min_value=0)
fractions = st.fractions(MIN_COORDINATE, MAX_COORDINATE)
raw_fraction_contours = planar.contours(fractions)
fractions_contours = st.builds(Contour.from_raw, raw_fraction_contours)
fraction_triangles = st.builds(
Polygon.from_raw,
planar.polygons(fractions, max_size=TRIANGULAR_CONTOUR_SIZE))
convex_divisors = st.sampled_from(
[constrained_delaunay_triangles, joined_constrained_delaunay_triangles])
coordinates_strategies_factories = {
int: st.integers,
Fraction: st.fractions,
float: st.floats
}
coordinates_strategies = st.sampled_from([
factory(MIN_COORDINATE, MAX_COORDINATE)
for factory in coordinates_strategies_factories.values()
from hypothesis_geometry import planar
from hypothesis_geometry.hints import Contour
from tests.strategies import floats
from tests.utils import (BoundPoint,
BoundPortedPointsListsPair,
PortedPoint)
def to_bound_with_ported_contours(raw: Contour) -> BoundPortedPointsListsPair:
return ([BoundPoint(x, y) for x, y in raw],
[PortedPoint(x, y) for x, y in raw])
contours_pairs = planar.contours(floats).map(to_bound_with_ported_contours)