From dc9921eecece6078f585198fbe8a8344a25c5dcf Mon Sep 17 00:00:00 2001 From: Peter Volf Date: Fri, 20 Dec 2024 21:04:35 +0100 Subject: [PATCH 1/2] chore: ruff commit hook upgrade, typing and linter fixes --- .pre-commit-config.yaml | 2 +- pyproject.toml | 5 +++- .../sbstudio/plugin/model/light_effects.py | 27 ++++++------------- .../operators/create_new_storyboard_entry.py | 11 +++++++- .../sbstudio/plugin/operators/prepare.py | 2 +- .../operators/remove_storyboard_entry.py | 15 ++++++++--- .../operators/run_full_proximity_check.py | 1 - .../sbstudio/plugin/tasks/light_effects.py | 1 - 8 files changed, 36 insertions(+), 28 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8719545e..65cf79cc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -8,7 +8,7 @@ repos: - id: trailing-whitespace - repo: https://github.com/charliermarsh/ruff-pre-commit - rev: v0.3.5 + rev: v0.8.4 hooks: - id: ruff args: [--fix, --exit-non-zero-on-fix] diff --git a/pyproject.toml b/pyproject.toml index 7f76e0f7..2e19bb25 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -42,7 +42,10 @@ pyclean = "^2.0.0" [tool.ruff] lint.ignore = ["B027", "B905", "C901", "E402", "E501", "E731"] lint.select = ["B", "C", "E", "F", "W"] -extend-exclude = ["src/modules/sbstudio/vendor"] +extend-exclude = [ + "src/modules/sbstudio/vendor", + "src/modules/sbstudio/i18n/translations.py" +] [build-system] requires = ["poetry-core>=1.0.0"] diff --git a/src/modules/sbstudio/plugin/model/light_effects.py b/src/modules/sbstudio/plugin/model/light_effects.py index 0a2e4ab8..764e0b28 100644 --- a/src/modules/sbstudio/plugin/model/light_effects.py +++ b/src/modules/sbstudio/plugin/model/light_effects.py @@ -3,18 +3,10 @@ import types import bpy +from collections.abc import Callable, Iterable, Sequence from functools import partial from operator import itemgetter -from typing import ( - cast, - Callable, - Iterable, - List, - Optional, - Sequence, - Tuple, - TYPE_CHECKING, -) +from typing import cast, Optional from bpy.path import abspath from bpy.props import ( @@ -54,9 +46,6 @@ from .mixins import ListMixin -if TYPE_CHECKING: - from sbstudio.api.types import Mapping - from sbstudio.plugin.model import StoryboardEntry __all__ = ("ColorFunctionProperties", "LightEffect", "LightEffectCollection") @@ -159,8 +148,8 @@ def test_is_in_front_of(plane: Optional[Plane], point: Coordinate3D) -> bool: _always_true = constant(True) -def get_color_function_names(self, context: Context) -> List[Tuple[str, str, str]]: - names: List[str] +def get_color_function_names(self, context: Context) -> list[tuple[str, str, str]]: + names: list[str] if self.path: absolute_path = abspath(self.path) @@ -398,7 +387,7 @@ def apply_on_colors( self, colors: Sequence[MutableRGBAColor], positions: Sequence[Coordinate3D], - mapping: Optional[List[int]], + mapping: Optional[list[int]], *, frame: int, random_seq: RandomSequence, @@ -422,7 +411,7 @@ def get_output_based_on_output_type( output_type: str, mapping_mode: str, output_function, - ) -> Tuple[Optional[List[Optional[float]]], Optional[float]]: + ) -> tuple[Optional[list[Optional[float]]], Optional[float]]: """Get the float output(s) for color ramp or image indexing based on the output type. Args: @@ -432,9 +421,9 @@ def get_output_based_on_output_type( Returns: individual and common outputs """ - outputs: Optional[List[Optional[float]]] = None + outputs: Optional[list[Optional[float]]] = None common_output: Optional[float] = None - order: Optional[List[int]] = None + order: Optional[list[int]] = None if output_type == "FIRST_COLOR": common_output = 0.0 diff --git a/src/modules/sbstudio/plugin/operators/create_new_storyboard_entry.py b/src/modules/sbstudio/plugin/operators/create_new_storyboard_entry.py index ea844485..23fd2fa3 100644 --- a/src/modules/sbstudio/plugin/operators/create_new_storyboard_entry.py +++ b/src/modules/sbstudio/plugin/operators/create_new_storyboard_entry.py @@ -1,5 +1,14 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + from .base import StoryboardOperator +if TYPE_CHECKING: + from bpy.types import Context + + from sbstudio.plugin.model.storyboard import Storyboard + __all__ = ("CreateNewStoryboardEntryOperator",) @@ -10,6 +19,6 @@ class CreateNewStoryboardEntryOperator(StoryboardOperator): bl_label = "Create New Storyboard Entry" bl_description = "Creates a new storyboard entry at the end of the storyboard." - def execute_on_storyboard(self, storyboard, context): + def execute_on_storyboard(self, storyboard: Storyboard, context: Context): storyboard.add_new_entry(name="Untitled", select=True) return {"FINISHED"} diff --git a/src/modules/sbstudio/plugin/operators/prepare.py b/src/modules/sbstudio/plugin/operators/prepare.py index ba0ccfcd..708f63bb 100644 --- a/src/modules/sbstudio/plugin/operators/prepare.py +++ b/src/modules/sbstudio/plugin/operators/prepare.py @@ -1,6 +1,6 @@ from bpy.types import Operator -from sbstudio.plugin.constants import Collections, Templates +from sbstudio.plugin.constants import Collections from sbstudio.plugin.objects import link_object_to_scene from sbstudio.plugin.state import get_file_specific_state diff --git a/src/modules/sbstudio/plugin/operators/remove_storyboard_entry.py b/src/modules/sbstudio/plugin/operators/remove_storyboard_entry.py index b239d605..51ed1668 100644 --- a/src/modules/sbstudio/plugin/operators/remove_storyboard_entry.py +++ b/src/modules/sbstudio/plugin/operators/remove_storyboard_entry.py @@ -1,9 +1,18 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + from sbstudio.plugin.constants import Collections from sbstudio.plugin.model.storyboard import get_storyboard from sbstudio.plugin.utils.transition import find_transition_constraint_between from .base import StoryboardOperator +if TYPE_CHECKING: + from bpy.types import Context + + from sbstudio.plugin.model.storyboard import Storyboard, StoryboardEntry + __all__ = ("RemoveStoryboardEntryOperator",) @@ -15,19 +24,19 @@ class RemoveStoryboardEntryOperator(StoryboardOperator): bl_description = "Remove the selected entry from the storyboard" @classmethod - def poll(cls, context): + def poll(cls, context: Context): return ( StoryboardOperator.poll(context) and get_storyboard(context=context).active_entry is not None ) - def execute_on_storyboard(self, storyboard, context): + def execute_on_storyboard(self, storyboard: Storyboard, context: Context): remove_constraints_for_storyboard_entry(storyboard.active_entry) storyboard.remove_active_entry() return {"FINISHED"} -def remove_constraints_for_storyboard_entry(entry): +def remove_constraints_for_storyboard_entry(entry: StoryboardEntry): if not entry: return diff --git a/src/modules/sbstudio/plugin/operators/run_full_proximity_check.py b/src/modules/sbstudio/plugin/operators/run_full_proximity_check.py index 0ce63197..e93e5015 100644 --- a/src/modules/sbstudio/plugin/operators/run_full_proximity_check.py +++ b/src/modules/sbstudio/plugin/operators/run_full_proximity_check.py @@ -1,4 +1,3 @@ -from numpy import array, float32 from typing import Literal from bpy.types import Context, Operator diff --git a/src/modules/sbstudio/plugin/tasks/light_effects.py b/src/modules/sbstudio/plugin/tasks/light_effects.py index 066ccdcd..95884f22 100644 --- a/src/modules/sbstudio/plugin/tasks/light_effects.py +++ b/src/modules/sbstudio/plugin/tasks/light_effects.py @@ -17,7 +17,6 @@ if TYPE_CHECKING: from bpy.types import Depsgraph, Scene - from sbstudio.api.types import Mapping __all__ = ("UpdateLightEffectsTask",) From 72c5900b8bf8cb454f366d65ba21ef33c2c6111f Mon Sep 17 00:00:00 2001 From: Peter Volf Date: Fri, 20 Dec 2024 21:12:46 +0100 Subject: [PATCH 2/2] feat: add StoryboardEntry.purpose, make show segments available for rendering, some typing improvements and refactoring --- src/modules/sbstudio/api/base.py | 67 +++-- .../sbstudio/plugin/model/storyboard.py | 136 +++++++-- .../plugin/operators/create_takeoff_grid.py | 6 +- src/modules/sbstudio/plugin/operators/land.py | 13 +- .../plugin/operators/return_to_home.py | 277 ++++++++++-------- .../sbstudio/plugin/operators/takeoff.py | 11 +- .../sbstudio/plugin/operators/utils.py | 106 +++++-- .../plugin/panels/storyboard_editor.py | 1 + src/modules/sbstudio/utils.py | 28 +- 9 files changed, 433 insertions(+), 212 deletions(-) diff --git a/src/modules/sbstudio/api/base.py b/src/modules/sbstudio/api/base.py index aa0d6c69..135543ff 100644 --- a/src/modules/sbstudio/api/base.py +++ b/src/modules/sbstudio/api/base.py @@ -2,6 +2,7 @@ import re from base64 import b64encode +from collections.abc import Iterator, Sequence from contextlib import contextmanager from gzip import compress from http.client import HTTPResponse @@ -10,7 +11,7 @@ from pathlib import Path from shutil import copyfileobj from ssl import create_default_context, CERT_NONE -from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple +from typing import Any, Optional from urllib.error import HTTPError from urllib.parse import urljoin from urllib.request import Request, urlopen @@ -321,7 +322,7 @@ def decompose_points( *, min_distance: float, method: str = "greedy", - ) -> List[int]: + ) -> list[int]: """Decomposes a set of points into multiple groups while ensuring that the minimum distance of points within the same group is at least as large as the given threshold. @@ -342,44 +343,51 @@ def decompose_points( def export( self, + *, validation: SafetyCheckParams, - trajectories: Dict[str, Trajectory], - lights: Optional[Dict[str, LightProgram]] = None, - yaw_setpoints: Optional[Dict[str, YawSetpointList]] = None, + trajectories: dict[str, Trajectory], + lights: Optional[dict[str, LightProgram]] = None, + yaw_setpoints: Optional[dict[str, YawSetpointList]] = None, output: Optional[Path] = None, show_title: Optional[str] = None, show_type: str = "outdoor", + show_segments: Optional[dict[str, tuple[float, float]]] = None, ndigits: int = 3, timestamp_offset: Optional[float] = None, time_markers: Optional[TimeMarkers] = None, cameras: Optional[list[Camera]] = None, renderer: str = "skyc", - renderer_params: Optional[Dict[str, Any]] = None, + renderer_params: Optional[dict[str, Any]] = None, ) -> Optional[bytes]: - """Export drone show data into Skybrush Compiled Format (.skyc). + """ + Export drone show data. Parameters: - validation: safety check parameters - trajectories: dictionary of trajectories indexed by drone names - lights: dictionary of light programs indexed by drone names - yaw_setpoints: dictionary of yaw setpoints indexed by drone names - output: the file path where the output should be saved or `None` - if the output must be returned instead of saving it to a file - show_title: arbitrary show title; `None` if no title is needed - show_type: type of the show; must be one of `outdoor` or `indoor` - ndigits: round floats to this precision - timestamp_offset: when specified, adds this timestamp offset to the - metadata of the .skyc file, which is then used later for display - purposes in Skybrush Viewer - time_markers: when specified, time markers will be exported to the - .skyc file as temporal cues - cameras: when specified, list of cameras to include in the environment + validation: Safety check parameters. + trajectories: Dictionary of trajectories indexed by drone names. + lights: Dictionary of light programs indexed by drone names. + yaw_setpoints: Dictionary of yaw setpoints indexed by drone names. + output: The file path where the output should be saved or `None` + if the output must be returned instead of saving it to a file. + show_title: Arbitrary show title; `None` if no title is needed. + show_type: Type of the show; must be one of `outdoor` or `indoor`. + show_segments: Dictionary that maps show segment IDs to a start + (inclusive) and end (exclusive) timestamp pair. + ndigits: Round floats to this precision. + timestamp_offset: When specified, adds this timestamp offset to the + show metadata, which can later be used for display purposes in + Skybrush Viewer. + time_markers: When specified, time markers will be exported as + temporal cues. + cameras: When specified, list of cameras to include in the environment. + renderer: The renderer to use to export the show. + renderer_params: Extra parameters for the renderer. Note: drone names must match in trajectories and lights Returns: - the drone show data in .skyc format or `None` if an output filename - was specified + The exported drone show data or `None` if an `output` filename + was specified. """ meta = {} @@ -389,6 +397,9 @@ def export( if timestamp_offset is not None: meta["timestampOffset"] = timestamp_offset + if show_segments is not None: + meta["segments"] = show_segments + if lights is None: lights = {name: LightProgram() for name in trajectories.keys()} @@ -451,7 +462,7 @@ def create_formation_from_svg( num_points: int, size: float, angle: float, - ) -> Tuple[List[Point3D], List[Color3D]]: + ) -> tuple[list[Point3D], list[Color3D]]: """Samples the path objects of an SVG string into a list of coordinates and corresponding colors. @@ -490,7 +501,7 @@ def create_formation_from_svg( def generate_plots( self, - trajectories: Dict[str, Trajectory], + trajectories: dict[str, Trajectory], output: Path, validation: SafetyCheckParams, plots: Sequence[str] = ("pos", "vel", "nn"), @@ -563,7 +574,7 @@ def match_points( target: Sequence[Coordinate3D], *, radius: Optional[float] = None, - ) -> Tuple[Mapping, Optional[float]]: + ) -> tuple[Mapping, Optional[float]]: """Matches the points of a source point set to the points of a target point set in a way that ensures collision-free straight-line trajectories between the matched points when neither the source nor the @@ -594,7 +605,7 @@ def plan_landing( velocity: float, target_altitude: float = 0, spindown_time: float = 5, - ) -> Tuple[List[int], List[int]]: + ) -> tuple[list[int], list[int]]: """Plans the landing trajectories for a set of drones, assuming that they should maintain a given minimum distance while the motors are running and that they land with constant speed. diff --git a/src/modules/sbstudio/plugin/model/storyboard.py b/src/modules/sbstudio/plugin/model/storyboard.py index d97cb00e..9117b57a 100644 --- a/src/modules/sbstudio/plugin/model/storyboard.py +++ b/src/modules/sbstudio/plugin/model/storyboard.py @@ -1,8 +1,13 @@ from __future__ import annotations -import bpy +import enum import json +from dataclasses import dataclass +from operator import attrgetter +from uuid import uuid4 +from typing import TYPE_CHECKING, Optional +import bpy from bpy.props import ( BoolProperty, CollectionProperty, @@ -12,9 +17,6 @@ StringProperty, ) from bpy.types import PropertyGroup -from operator import attrgetter -from uuid import uuid4 -from typing import Dict, List, Optional, Tuple, TYPE_CHECKING from sbstudio.api.types import Mapping from sbstudio.plugin.constants import ( @@ -32,7 +34,12 @@ if TYPE_CHECKING: from bpy.types import bpy_prop_collection, Collection, Context -__all__ = ("ScheduleOverride", "StoryboardEntry", "Storyboard") +__all__ = ( + "ScheduleOverride", + "StoryboardEntry", + "Storyboard", + "StoryboardEntryPurpose", +) class ScheduleOverride(PropertyGroup): @@ -78,7 +85,7 @@ class ScheduleOverride(PropertyGroup): @property def label(self) -> str: - parts: List[str] = [f"@{self.index}"] + parts: list[str] = [f"@{self.index}"] if self.pre_delay != 0: parts.append(f"dep {self.pre_delay}") if self.post_delay != 0: @@ -108,6 +115,28 @@ def _set_frame_end(self: StoryboardEntry, value: int) -> None: self.duration = value - self.frame_start +@dataclass(frozen=True) +class _StoryboardEntryPurposeMixin: + ui_name: str + order: int + + +class StoryboardEntryPurpose(_StoryboardEntryPurposeMixin, enum.Enum): + """ + Storyboard entry purposes in the order in which they can follow each-other. + + The `name` of the enum is used to identify values in/for Blender. + """ + + TAKEOFF = "Takeoff", 1 + SHOW = "Show", 2 + LANDING = "Landing", 3 + + @property + def bpy_enum_item(self) -> tuple[str, str, str, int]: + return (self.name, self.ui_name, "", self.order) + + class StoryboardEntry(PropertyGroup): """Blender property group representing a single entry in the storyboard of the drone show. @@ -187,6 +216,22 @@ class StoryboardEntry(PropertyGroup): default="SYNCHRONIZED", options=set(), ) + + purpose = EnumProperty( + items=[ + StoryboardEntryPurpose.TAKEOFF.bpy_enum_item, + StoryboardEntryPurpose.SHOW.bpy_enum_item, + StoryboardEntryPurpose.LANDING.bpy_enum_item, + ], + name="Purpose", + description=( + "The purpose of the entry in the show. A valid show must start with 0 or more " + "takeoff entries, followed by any number of show entries, and end with 0 or more " + "landing entries." + ), + default=StoryboardEntryPurpose.SHOW.name, + ) + pre_delay_per_drone_in_frames = FloatProperty( name="Departure delay", description=( @@ -319,13 +364,13 @@ def is_staggered(self) -> bool: """Whether the transition is staggered.""" return self.transition_schedule == "STAGGERED" - def get_enabled_schedule_override_map(self) -> Dict[int, ScheduleOverride]: + def get_enabled_schedule_override_map(self) -> dict[int, ScheduleOverride]: """Returns a dictionary mapping indices of markers in the source formation to the corresponding transition schedule overrides. Only enabled schedule overrides are considered. """ - result: Dict[int, ScheduleOverride] = {} + result: dict[int, ScheduleOverride] = {} if self.schedule_overrides_enabled: for override in self.schedule_overrides: @@ -432,6 +477,7 @@ def add_new_entry( frame_start: Optional[int] = None, duration: Optional[int] = None, *, + purpose: StoryboardEntryPurpose = StoryboardEntryPurpose.SHOW, formation: Optional[Collection] = None, select: bool = False, context: Optional[Context] = None, @@ -446,6 +492,7 @@ def add_new_entry( sensible default duration: the duration of the new entry; `None` chooses a sensible default + purpose: The purpose of the entry. formation: the formation that the newly added entry should refer to select: whether to select the newly added entry after it was created @@ -473,10 +520,11 @@ def add_new_entry( if duration is None or duration < 0: duration = fps * DEFAULT_STORYBOARD_ENTRY_DURATION - entry = self.entries.add() + entry: StoryboardEntry = self.entries.add() entry.frame_start = frame_start entry.duration = duration entry.name = name + entry.purpose = purpose.name if ( formation is None @@ -686,7 +734,7 @@ def get_formation_status_at_frame(self, frame: int) -> str: def get_frame_range_of_formation_or_transition_at_frame( self, frame: int - ) -> Optional[Tuple[int, int]]: + ) -> Optional[tuple[int, int]]: """Returns the start and end frame of the current formation or transition that contains the given frame. @@ -760,7 +808,7 @@ def second_entry(self) -> Optional[StoryboardEntry]: else: return None - def validate_and_sort_entries(self) -> List[StoryboardEntry]: + def validate_and_sort_entries(self) -> list[StoryboardEntry]: """Validates the entries in the storyboard and sorts them by start time, keeping the active entry index point at the same entry as before. @@ -774,8 +822,36 @@ def validate_and_sort_entries(self) -> List[StoryboardEntry]: entries = list(self.entries) entries.sort(key=StoryboardEntry.sort_key) - # Check that entries do not overlap - for index, (entry, next_entry) in enumerate(zip(entries, entries[1:])): + for validator in ( + self._validate_entry_sequence, + self._validate_formation_size_contraints, + ): + validator(entries) + + active_entry = self.active_entry + self._sort_entries() + self.active_entry = active_entry + + # Retrieve the entries again because _sort_entries() might have changed + # the ordering + return sorted(self.entries, key=StoryboardEntry.sort_key) + + def _validate_entry_sequence(self, sorted_entries: list[StoryboardEntry]) -> None: + """ + Validates the given entry sequence by ensuring consecutive items can follow each-other. + + Validation rules: + + - Entries must not overlap. + - Entry purposes are in the correct order. + + Raises: + StoryboardValidationError: If validation fails. + """ + for index, (entry, next_entry) in enumerate( + zip(sorted_entries, sorted_entries[1:]) + ): + # -- No overlap. if entry.frame_end >= next_entry.frame_start: raise StoryboardValidationError( f"Storyboard entry {entry.name!r} at index {index + 1} and " @@ -783,10 +859,30 @@ def validate_and_sort_entries(self) -> List[StoryboardEntry]: f"{next_entry.name!r}" ) - # Check sizes of constraints + # -- Purposes are in the correct order. + entry_purpose, next_purpose = ( + StoryboardEntryPurpose[entry.purpose], + StoryboardEntryPurpose[next_entry.purpose], + ) + if entry_purpose.order > next_purpose.order: + raise StoryboardValidationError( + f"Storyboard entry {entry_purpose.name!r} has purpose " + f"{StoryboardEntryPurpose[entry_purpose].ui_name}, which can not be followed by " + f"a {StoryboardEntryPurpose[ next_purpose].ui_name} entry." + ) + + def _validate_formation_size_contraints( + self, sorted_entries: list[StoryboardEntry] + ) -> None: + """ + Validates that the given entries satisfy formation size constraints. + + Raises: + StoryboardValidationError: If validation fails. + """ drones = Collections.find_drones(create=False) num_drones = len(drones.objects) if drones else 0 - for entry in entries: + for entry in sorted_entries: formation = entry.formation if formation is None: continue @@ -803,14 +899,6 @@ def validate_and_sort_entries(self) -> List[StoryboardEntry]: f"Storyboard entry {entry.name!r} contains a formation with {num_markers} drones but {msg}" ) - active_entry = self.active_entry - self._sort_entries() - self.active_entry = active_entry - - # Retrieve the entries again because _sort_entries() might have changed - # the ordering - return sorted(self.entries, key=StoryboardEntry.sort_key) - def _on_active_entry_moving_down(self, this_entry, next_entry) -> bool: pad = next_entry.frame_start - this_entry.frame_end @@ -838,7 +926,7 @@ def _sort_entries(self) -> None: @with_context -def get_storyboard(context: Optional[Context] = None) -> Storyboard: +def get_storyboard(*, context: Optional[Context] = None) -> Storyboard: """Helper function to retrieve the storyboard of the add-on from the given context object. """ diff --git a/src/modules/sbstudio/plugin/operators/create_takeoff_grid.py b/src/modules/sbstudio/plugin/operators/create_takeoff_grid.py index 0cf7d1dc..09fa92a5 100644 --- a/src/modules/sbstudio/plugin/operators/create_takeoff_grid.py +++ b/src/modules/sbstudio/plugin/operators/create_takeoff_grid.py @@ -4,7 +4,6 @@ from bpy.types import Operator from numpy import array, column_stack, mgrid, repeat, tile, zeros -from typing import List from sbstudio.model.types import Coordinate3D from sbstudio.plugin.constants import Collections, Formations, Templates @@ -13,7 +12,7 @@ create_keyframe_for_diffuse_color_of_material, ) from sbstudio.plugin.model.formation import add_points_to_formation, create_formation -from sbstudio.plugin.model.storyboard import get_storyboard +from sbstudio.plugin.model.storyboard import StoryboardEntryPurpose, get_storyboard from sbstudio.plugin.operators.detach_materials_from_template import ( detach_material_from_drone_template, ) @@ -64,7 +63,7 @@ def create_points_of_takeoff_grid( spacing_col: float = 1, intra_slot_spacing_row: float = 0.5, intra_slot_spacing_col: float = 0.5, -) -> List[Coordinate3D]: +) -> list[Coordinate3D]: """Creates the points of a takeoff grid centered at the given coordinate. Parameters: @@ -390,6 +389,7 @@ def _run(self, context): formation=create_formation(Formations.TAKEOFF_GRID, points), frame_start=context.scene.frame_start, duration=0, + purpose=StoryboardEntryPurpose.TAKEOFF, select=True, context=context, ) diff --git a/src/modules/sbstudio/plugin/operators/land.py b/src/modules/sbstudio/plugin/operators/land.py index 35a68c5d..c1c76fe1 100644 --- a/src/modules/sbstudio/plugin/operators/land.py +++ b/src/modules/sbstudio/plugin/operators/land.py @@ -11,7 +11,11 @@ from sbstudio.plugin.constants import Collections from sbstudio.plugin.model.formation import create_formation from sbstudio.plugin.model.safety_check import get_proximity_warning_threshold -from sbstudio.plugin.model.storyboard import get_storyboard +from sbstudio.plugin.model.storyboard import ( + Storyboard, + StoryboardEntryPurpose, + get_storyboard, +) from sbstudio.plugin.utils.evaluator import create_position_evaluator from sbstudio.plugin.utils.transition import find_transition_constraint_between @@ -68,14 +72,14 @@ class LandOperator(StoryboardOperator): ) @classmethod - def poll(cls, context): + def poll(cls, context: Context): if not super().poll(context): return False drones = Collections.find_drones(create=False) return drones is not None and len(drones.objects) > 0 - def invoke(self, context, event): + def invoke(self, context: Context, event): self.start_frame = max( context.scene.frame_current, get_storyboard(context=context).frame_end ) @@ -89,7 +93,7 @@ def execute_on_storyboard(self, storyboard, entries, context): success = False return {"FINISHED"} if success else {"CANCELLED"} - def _run(self, storyboard, *, context) -> bool: + def _run(self, storyboard: Storyboard, *, context: Context) -> bool: bpy.ops.skybrush.prepare() if not self._validate_start_frame(context): @@ -166,6 +170,7 @@ def _run(self, storyboard, *, context) -> bool: frame_start=end_of_landing, duration=0, select=True, + purpose=StoryboardEntryPurpose.LANDING, context=context, ) assert entry is not None diff --git a/src/modules/sbstudio/plugin/operators/return_to_home.py b/src/modules/sbstudio/plugin/operators/return_to_home.py index 6643a711..621c5e80 100644 --- a/src/modules/sbstudio/plugin/operators/return_to_home.py +++ b/src/modules/sbstudio/plugin/operators/return_to_home.py @@ -1,3 +1,5 @@ +from collections.abc import Sequence + import bpy from bpy.props import FloatProperty, IntProperty, BoolProperty @@ -6,6 +8,7 @@ from math import ceil, sqrt from sbstudio.errors import SkybrushStudioError +from sbstudio.model.types import Coordinate3D from sbstudio.plugin.api import call_api_from_blender_operator from sbstudio.plugin.constants import Collections from sbstudio.plugin.actions import ( @@ -14,7 +17,11 @@ ) from sbstudio.plugin.model.formation import create_formation, get_markers_from_formation from sbstudio.plugin.model.safety_check import get_proximity_warning_threshold -from sbstudio.plugin.model.storyboard import get_storyboard +from sbstudio.plugin.model.storyboard import ( + Storyboard, + StoryboardEntryPurpose, + get_storyboard, +) from sbstudio.plugin.utils.evaluator import create_position_evaluator from .base import StoryboardOperator @@ -96,14 +103,14 @@ class ReturnToHomeOperator(StoryboardOperator): ) @classmethod - def poll(cls, context): + def poll(cls, context: Context): if not super().poll(context): return False drones = Collections.find_drones(create=False) return drones is not None and len(drones.objects) > 0 - def draw(self, context): + def draw(self, context: Context): layout = self.layout layout.use_property_split = True @@ -135,7 +142,7 @@ def invoke(self, context, event): ) return context.window_manager.invoke_props_dialog(self) - def execute_on_storyboard(self, storyboard, entries, context): + def execute_on_storyboard(self, storyboard: Storyboard, entries, context: Context): try: success = self._run(storyboard, context=context) except SkybrushStudioError: @@ -146,7 +153,7 @@ def execute_on_storyboard(self, storyboard, entries, context): def _should_use_smart_rth(self) -> bool: return self.use_smart_rth and is_smart_rth_enabled_globally() - def _run(self, storyboard, *, context) -> bool: + def _run(self, storyboard: Storyboard, *, context: Context) -> bool: bpy.ops.skybrush.prepare() if not self._validate_start_frame(context): @@ -173,134 +180,156 @@ def _run(self, storyboard, *, context) -> bool: min_distance=get_proximity_warning_threshold(context), operator=self, ) + + run_rth = self._run_smart_rth if use_smart_rth else self._run_base_rth + result = run_rth(storyboard, source=source, target=target, context=context) + + # Recalculate the transition leading to the target formation + bpy.ops.skybrush.recalculate_transitions(scope="TO_SELECTED") + return result + + def _run_base_rth( + self, + storyboard: Storyboard, + *, + source: Sequence[Coordinate3D], + target: Sequence[Coordinate3D], + context: Context, + ) -> bool: fps = context.scene.render.fps + diffs = [ + sqrt((s[0] - t[0]) ** 2 + (s[1] - t[1]) ** 2 + (s[2] - t[2]) ** 2) + for s, t in zip(source, target) + ] + + # Calculate RTH duration from max distance to travel and the + # average velocity + max_distance = max(diffs) + rth_duration = ceil((max_distance / self.velocity) * fps) + + # Extend the duration of the last formation to the frame where we want + # to start the RTH maneuver + if len(storyboard.entries) > 0: + storyboard.last_entry.extend_until(self.start_frame) + + # Calculate when the RTH should end + end_of_rth = self.start_frame + rth_duration + + # Add a new storyboard entry with the given formation + storyboard.add_new_entry( + formation=create_formation("Return to home", target), + frame_start=end_of_rth, + duration=0, + select=True, + purpose=StoryboardEntryPurpose.LANDING, + context=context, + ) - if use_smart_rth: - # Set up non-trivial parameters - # TODO: get them as explicit parameter if needed - settings = getattr(context.scene.skybrush, "settings", None) - max_acceleration = settings.max_acceleration if settings else 4 - min_distance = get_proximity_warning_threshold(context) - land_speed = min(self.velocity_z, 0.5) - - # call API to create smart RTH plan - with call_api_from_blender_operator(self) as api: - plan = api.plan_smart_rth( - source, - target, - max_velocity_xy=self.velocity, - max_velocity_z=self.velocity_z, - max_acceleration=max_acceleration, - min_distance=min_distance, - rth_model="straight_line_with_neck", - ) - if not plan.start_times or not plan.durations: - return False - - # Add a new storyboard entry for the smart RTH formation - # TODO: What should happen if there is already a formation with the - # same name? - entry = storyboard.add_new_entry( - formation=create_formation("Smart return to home", source), - frame_start=self.start_frame, - duration=int(ceil((plan.duration + self.altitude / land_speed) * fps)), - select=True, - context=context, - ) - assert entry is not None - markers = get_markers_from_formation(entry.formation) - - # generate smart RTH trajectories in the new formation - for start_time, duration, inner_points, p, q, marker in zip( - plan.start_times, - plan.durations, - plan.inner_points, + def _run_smart_rth( + self, + storyboard: Storyboard, + *, + source: Sequence[Coordinate3D], + target: Sequence[Coordinate3D], + context: Context, + ) -> bool: + fps = context.scene.render.fps + + # Set up non-trivial parameters + # TODO: get them as explicit parameter if needed + settings = getattr(context.scene.skybrush, "settings", None) + max_acceleration = settings.max_acceleration if settings else 4 + min_distance = get_proximity_warning_threshold(context) + land_speed = min(self.velocity_z, 0.5) + + # call API to create smart RTH plan + with call_api_from_blender_operator(self) as api: + plan = api.plan_smart_rth( source, target, - markers, - strict=True, - ): - action = ensure_action_exists_for_object( - marker, name=f"Animation data for {marker.name}", clean=True - ) + max_velocity_xy=self.velocity, + max_velocity_z=self.velocity_z, + max_acceleration=max_acceleration, + min_distance=min_distance, + rth_model="straight_line_with_neck", + ) + if not plan.start_times or not plan.durations: + return False - f_curves = [] - for i in range(3): - f_curve = find_f_curve_for_data_path_and_index( - action, "location", i - ) - if f_curve is None: - f_curve = action.fcurves.new("location", index=i) - else: - # We should clear the keyframes that fall within the - # range of our keyframes. Currently it's not needed because - # it's a freshly created marker so it can't have any - # keyframes that we don't know about. - print(f"Already existing F-curve! {marker.name} {i}") - pass - f_curves.append(f_curve) - insert = [ - partial(f_curve.keyframe_points.insert, options={"FAST"}) - for f_curve in f_curves - ] - path_points = [] - if start_time > 0: - path_points.append((0, *p)) - path_points.append((start_time, *p)) - path_points.extend(tuple(inner_points)) - path_points.extend( + # Add a new storyboard entry for the smart RTH formation + # TODO: What should happen if there is already a formation with the + # same name? + entry = storyboard.add_new_entry( + formation=create_formation("Smart return to home", source), + frame_start=self.start_frame, + duration=int(ceil((plan.duration + self.altitude / land_speed) * fps)), + select=True, + purpose=StoryboardEntryPurpose.LANDING, + context=context, + ) + assert entry is not None + markers = get_markers_from_formation(entry.formation) + + # generate smart RTH trajectories in the new formation + for start_time, duration, inner_points, p, q, marker in zip( + plan.start_times, + plan.durations, + plan.inner_points, + source, + target, + markers, + strict=True, + ): + action = ensure_action_exists_for_object( + marker, name=f"Animation data for {marker.name}", clean=True + ) + + f_curves = [] + for i in range(3): + f_curve = find_f_curve_for_data_path_and_index(action, "location", i) + if f_curve is None: + f_curve = action.fcurves.new("location", index=i) + else: + # We should clear the keyframes that fall within the + # range of our keyframes. Currently it's not needed because + # it's a freshly created marker so it can't have any + # keyframes that we don't know about. + print(f"Already existing F-curve! {marker.name} {i}") + pass + f_curves.append(f_curve) + insert = [ + partial(f_curve.keyframe_points.insert, options={"FAST"}) + for f_curve in f_curves + ] + path_points = [] + if start_time > 0: + path_points.append((0, *p)) + path_points.append((start_time, *p)) + path_points.extend(tuple(inner_points)) + path_points.extend( + ( + (start_time + duration, *q), ( - (start_time + duration, *q), - ( - start_time + duration + self.altitude / land_speed, - q[0], - q[1], - 0, # TODO: starting position would be better than explicit 0 - ), - ) + start_time + duration + self.altitude / land_speed, + q[0], + q[1], + 0, # TODO: starting position would be better than explicit 0 + ), ) - for point in path_points: - frame = int(self.start_frame + point[0] * fps) - keyframes = ( - insert[0](frame, point[1]), - insert[1](frame, point[2]), - insert[2](frame, point[3]), - ) - for keyframe in keyframes: - keyframe.interpolation = "LINEAR" - # Commit the insertions that we've made in "fast" mode - for f_curve in f_curves: - f_curve.update() - else: - diffs = [ - sqrt((s[0] - t[0]) ** 2 + (s[1] - t[1]) ** 2 + (s[2] - t[2]) ** 2) - for s, t in zip(source, target) - ] - - # Calculate RTH duration from max distance to travel and the - # average velocity - max_distance = max(diffs) - rth_duration = ceil((max_distance / self.velocity) * fps) - - # Extend the duration of the last formation to the frame where we want - # to start the RTH maneuver - if len(storyboard.entries) > 0: - storyboard.last_entry.extend_until(self.start_frame) - - # Calculate when the RTH should end - end_of_rth = self.start_frame + rth_duration - - # Add a new storyboard entry with the given formation - storyboard.add_new_entry( - formation=create_formation("Return to home", target), - frame_start=end_of_rth, - duration=0, - select=True, - context=context, ) + for point in path_points: + frame = int(self.start_frame + point[0] * fps) + keyframes = ( + insert[0](frame, point[1]), + insert[1](frame, point[2]), + insert[2](frame, point[3]), + ) + for keyframe in keyframes: + keyframe.interpolation = "LINEAR" + # Commit the insertions that we've made in "fast" mode + for f_curve in f_curves: + f_curve.update() - # Recalculate the transition leading to the target formation - bpy.ops.skybrush.recalculate_transitions(scope="TO_SELECTED") return True def _validate_start_frame(self, context: Context) -> bool: diff --git a/src/modules/sbstudio/plugin/operators/takeoff.py b/src/modules/sbstudio/plugin/operators/takeoff.py index 6630fa93..0a44c798 100644 --- a/src/modules/sbstudio/plugin/operators/takeoff.py +++ b/src/modules/sbstudio/plugin/operators/takeoff.py @@ -4,7 +4,6 @@ from bpy.types import Context from math import ceil, inf -from sbstudio.api.errors import SkybrushStudioAPIError from sbstudio.errors import SkybrushStudioError from sbstudio.math.nearest_neighbors import find_nearest_neighbors from sbstudio.plugin.api import call_api_from_blender_operator, get_api @@ -14,7 +13,11 @@ ensure_formation_consists_of_points, ) from sbstudio.plugin.model.safety_check import get_proximity_warning_threshold -from sbstudio.plugin.model.storyboard import get_storyboard, Storyboard +from sbstudio.plugin.model.storyboard import ( + Storyboard, + StoryboardEntryPurpose, + get_storyboard, +) from sbstudio.plugin.operators.recalculate_transitions import ( RecalculationTask, recalculate_transitions, @@ -103,7 +106,7 @@ def invoke(self, context: Context, event): self.start_frame = int(max(min(context.scene.frame_current, end), start)) return context.window_manager.invoke_props_dialog(self) - def execute_on_storyboard(self, storyboard, entries, context: Context): + def execute_on_storyboard(self, storyboard: Storyboard, entries, context: Context): try: success = self._run(storyboard, context=context) except SkybrushStudioError: @@ -176,6 +179,7 @@ def _run(self, storyboard: Storyboard, *, context: Context) -> bool: formation=create_formation(Formations.TAKEOFF_GRID, source), frame_start=self.start_frame, duration=0, + purpose=StoryboardEntryPurpose.TAKEOFF, select=False, context=context, ) @@ -193,6 +197,7 @@ def _run(self, storyboard: Storyboard, *, context: Context) -> bool: formation=create_formation(Formations.TAKEOFF, target), frame_start=end_of_takeoff, duration=0, + purpose=StoryboardEntryPurpose.TAKEOFF, select=True, context=context, ) diff --git a/src/modules/sbstudio/plugin/operators/utils.py b/src/modules/sbstudio/plugin/operators/utils.py index d1fb9fbe..4a7467f8 100644 --- a/src/modules/sbstudio/plugin/operators/utils.py +++ b/src/modules/sbstudio/plugin/operators/utils.py @@ -5,16 +5,22 @@ from bpy.path import basename from bpy.types import Context +from itertools import groupby from natsort import natsorted from operator import attrgetter from pathlib import Path -from typing import Dict, Optional, Tuple +from typing import Any, Optional, cast from sbstudio.api.base import SkybrushStudioAPI from sbstudio.model.light_program import LightProgram from sbstudio.model.safety_check import SafetyCheckParams from sbstudio.model.trajectory import Trajectory from sbstudio.model.yaw import YawSetpointList +from sbstudio.plugin.model.storyboard import ( + StoryboardEntry, + StoryboardEntryPurpose, + get_storyboard, +) from sbstudio.plugin.constants import Collections from sbstudio.plugin.errors import SkybrushStudioExportWarning from sbstudio.model.file_formats import FileFormat @@ -22,6 +28,7 @@ from sbstudio.plugin.tasks.light_effects import suspended_light_effects from sbstudio.plugin.tasks.safety_check import suspended_safety_checks from sbstudio.plugin.utils import with_context +from sbstudio.plugin.utils.cameras import get_cameras_from_context from sbstudio.plugin.utils.sampling import ( frame_range, sample_colors_of_objects, @@ -31,8 +38,7 @@ sample_positions_colors_and_yaw_of_objects, ) from sbstudio.plugin.utils.time_markers import get_time_markers_from_context -from sbstudio.plugin.utils.cameras import get_cameras_from_context - +from sbstudio.utils import get_ends __all__ = ("get_drones_to_export", "export_show_to_file_using_api") @@ -40,6 +46,11 @@ log = logging.getLogger(__name__) +class _default_settings: + output_fps = 4 + light_output_fps = 4 + + ################################################################################ # Helper functions for exporter operators @@ -70,7 +81,7 @@ def get_drones_to_export(selected_only: bool = False): @with_context def _get_frame_range_from_export_settings( settings, *, context: Optional[Context] = None -) -> Optional[Tuple[int, int]]: +) -> Optional[tuple[int, int]]: """Returns the range of frames to export, based on the chosen export settings of the user. @@ -84,14 +95,59 @@ def _get_frame_range_from_export_settings( return resolve_frame_range(settings["frame_range"], context=context) +@with_context +def _get_segments(context: Optional[Context] = None) -> dict[str, tuple[float, float]]: + """ + Returns dictionary that maps show segment IDs to start (inclusive) and end (exclusive) timestamps. + + If invalid configuration is found for a segment, then the segment will be omitted + from the result. + """ + result: dict[str, tuple[float, float]] = {} + storyboard = get_storyboard(context=context) + fps = context.scene.render.fps + + entry_purpose_groups = groupby(storyboard.entries, lambda e: cast(str, e.purpose)) + + takeoff_entries: list[StoryboardEntry] | None = None + show_entries: list[StoryboardEntry] | None = None + landing_entries: list[StoryboardEntry] | None = None + show_valid = True + for purpose, entries in entry_purpose_groups: + if purpose == StoryboardEntryPurpose.TAKEOFF.name: + if not (show_entries is None and landing_entries is None): + show_valid = False + break + + takeoff_entries = list(entries) + elif purpose == StoryboardEntryPurpose.SHOW.name: + if landing_entries is not None: + show_valid = False + break + + show_entries = list(entries) + elif purpose == StoryboardEntryPurpose.LANDING.name: + landing_entries = list(entries) + + if show_valid: + if ends := get_ends(takeoff_entries): + result["takeoff"] = (ends[0].frame_start * fps, ends[1].frame_end * fps) + if ends := get_ends(show_entries): + result["show"] = (ends[0].frame_start * fps, ends[1].frame_end * fps) + if ends := get_ends(landing_entries): + result["landing"] = (ends[0].frame_start * fps, ends[1].frame_end * fps) + + return result + + @with_context def _get_trajectories_and_lights( drones, - settings: Dict, - bounds: Tuple[int, int], + settings: dict[str, Any], + bounds: tuple[int, int], *, context: Optional[Context] = None, -) -> Tuple[Dict[str, Trajectory], Dict[str, LightProgram]]: +) -> tuple[dict[str, Trajectory], dict[str, LightProgram]]: """Get trajectories and LED lights of all selected/picked objects. Parameters: @@ -103,11 +159,11 @@ def _get_trajectories_and_lights( Returns: dictionary of Trajectory and LightProgram objects indexed by object names """ - trajectory_fps = settings.get("output_fps", 4) - light_fps = settings.get("light_output_fps", 4) + trajectory_fps = settings.get("output_fps", _default_settings.output_fps) + light_fps = settings.get("light_output_fps", _default_settings.light_output_fps) - trajectories: Dict[str, Trajectory] - lights: Dict[str, LightProgram] + trajectories: dict[str, Trajectory] + lights: dict[str, LightProgram] if trajectory_fps == light_fps: # This is easy, we can iterate over the show once @@ -156,11 +212,11 @@ def _get_trajectories_and_lights( @with_context def _get_trajectories_lights_and_yaw_setpoints( drones, - settings: Dict, - bounds: Tuple[int, int], + settings: dict[str, Any], + bounds: tuple[int, int], *, context: Optional[Context] = None, -) -> Tuple[Dict[str, Trajectory], Dict[str, LightProgram], Dict[str, YawSetpointList]]: +) -> tuple[dict[str, Trajectory], dict[str, LightProgram], dict[str, YawSetpointList]]: """Get trajectories, LED lights and yaw setpoints of all selected/picked objects. Parameters: @@ -172,12 +228,12 @@ def _get_trajectories_lights_and_yaw_setpoints( Returns: dictionary of Trajectory, LightProgram and YawSetpointList objects indexed by object names """ - trajectory_fps = settings.get("output_fps", 4) - light_fps = settings.get("light_output_fps", 4) + trajectory_fps = settings.get("output_fps", _default_settings.output_fps) + light_fps = settings.get("light_output_fps", _default_settings.light_output_fps) - trajectories: Dict[str, Trajectory] - lights: Dict[str, LightProgram] - yaw_setpoints: Dict[str, YawSetpointList] + trajectories: dict[str, Trajectory] + lights: dict[str, LightProgram] + yaw_setpoints: dict[str, YawSetpointList] if trajectory_fps == light_fps: # This is easy, we can iterate over the show once @@ -236,7 +292,7 @@ def _get_trajectories_lights_and_yaw_setpoints( def export_show_to_file_using_api( api: SkybrushStudioAPI, context: Context, - settings: Dict, + settings: dict[str, Any], filepath: Path, format: FileFormat, ) -> None: @@ -269,7 +325,7 @@ def export_show_to_file_using_api( raise SkybrushStudioExportWarning("Selected frame range is empty") # determine list of drones to export - export_selected_only = settings.get("export_selected", False) + export_selected_only: bool = settings.get("export_selected", False) drones = list(get_drones_to_export(selected_only=export_selected_only)) if not drones: if export_selected_only: @@ -282,7 +338,7 @@ def export_show_to_file_using_api( ) # get yaw control enabled state - use_yaw_control = settings.get("use_yaw_control", False) + use_yaw_control: bool = settings.get("use_yaw_control", False) # get trajectories, light programs and yaw setpoints if use_yaw_control: @@ -335,6 +391,9 @@ def export_show_to_file_using_api( min_distance=safety_check.proximity_warning_threshold if safety_check else 3, ) + # get show segments + show_segments = _get_segments(context=context) + renderer_params = {} if "min_nav_altitude" in settings: renderer_params = {"min_nav_altitude": settings["min_nav_altitude"]} @@ -343,7 +402,7 @@ def export_show_to_file_using_api( if format is FileFormat.PDF: log.info("Exporting validation plots to .pdf") plots = settings.get("plots", ["pos", "vel", "nn"]) - fps = settings.get("output_fps", 4) + fps = settings.get("output_fps", _default_settings.output_fps) api.generate_plots( trajectories=trajectories, output=filepath, @@ -404,6 +463,7 @@ def export_show_to_file_using_api( api.export( show_title=show_title, show_type=show_type, + show_segments=show_segments, validation=validation, trajectories=trajectories, lights=lights, diff --git a/src/modules/sbstudio/plugin/panels/storyboard_editor.py b/src/modules/sbstudio/plugin/panels/storyboard_editor.py index 191b10b0..a0e6b3e4 100644 --- a/src/modules/sbstudio/plugin/panels/storyboard_editor.py +++ b/src/modules/sbstudio/plugin/panels/storyboard_editor.py @@ -77,6 +77,7 @@ def draw(self, context): col.prop(entry, "duration") col.prop(entry, "frame_end") col.prop(entry, "is_name_customized") + col.prop(entry, "purpose") col.popover( "OBJECT_PT_skybrush_transition_editor_pre", icon="TRACKING_CLEAR_BACKWARDS", diff --git a/src/modules/sbstudio/utils.py b/src/modules/sbstudio/utils.py index e54bdf4d..5e0ff938 100644 --- a/src/modules/sbstudio/utils.py +++ b/src/modules/sbstudio/utils.py @@ -1,10 +1,10 @@ import importlib.util from collections import OrderedDict -from collections.abc import MutableMapping +from collections.abc import Callable, Iterable, MutableMapping, Sequence from functools import wraps from pathlib import Path -from typing import Any, Callable, Generic, List, Sequence, TypeVar +from typing import Any, Generic, Optional, TypeVar from sbstudio.model.types import Coordinate3D @@ -46,6 +46,28 @@ def distance_sq_of(p: Coordinate3D, q: Coordinate3D) -> float: return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + (p[2] - q[2]) ** 2 +def get_ends(items: Optional[Iterable[T]]) -> tuple[T, T] | None: + """ + Returns the first and last item from the given iterable as a tuple if the + iterable is not empty, otherwise returns `None`. + + If the iterable contains only one item, then first and last will be that one item. + """ + if items is None: + return None + + iterator = iter(items) + try: + first = last = next(iterator) + except StopIteration: + return None + + for item in iterator: + last = item + + return (first, last) + + def negate(func: Callable[..., bool]) -> Callable[..., bool]: """Decorator that takes a function that returns a Boolean value and returns another function that returns the negation of the result of the original @@ -60,7 +82,7 @@ def new_func(*args, **kwds) -> bool: def simplify_path( - points: Sequence[T], *, eps: float, distance_func: Callable[[List[T], T, T], float] + points: Sequence[T], *, eps: float, distance_func: Callable[[list[T], T, T], float] ) -> Sequence[T]: """Simplifies a sequence of points to a similar sequence with fewer points, using a distance function and an acceptable error term.