sierra-research 1.3.6__py3-none-any.whl → 1.5.0__py3-none-any.whl

sierra/plugins/engine/argos/variables/cameras.py

@@ -0,0 +1,240 @@
+# Copyright 2020 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+
+"""Classes for specifying ARGoS cameras.
+
+Positions, timeline, and interpolation, for manipulating the frame
+capture/rendering perspective.
+
+"""
+
+# Core packages
+import typing as tp
+import math
+
+# 3rd party packages
+import implements
+
+# Project packages
+from sierra.core.variables.base_variable import IBaseVariable
+from sierra.core.utils import ArenaExtent
+from sierra.core.experiment import definition
+from sierra.core import types
+from sierra.core.vector import Vector3D
+import sierra.plugins.engine.argos.variables.exp_setup as exp
+
+
+@implements.implements(IBaseVariable)
+class QTCameraTimeline:
+    """Defines when/how to switch between camera perspectives within ARGoS.
+
+    Attributes:
+        interpolate: Should we interpolate between camera positions on our
+                      timeline ?
+
+        setup: Simulation experiment definitions.
+
+        extents: List of (X,Y,Zs) tuple of dimensions of arena areas to generate
+                 camera definitions for.
+
+    """
+
+    # If this default changes in ARGoS, it will need to be updated here too.
+    kARGOS_N_CAMERAS = 12
+
+    def __init__(
+        self, setup: exp.ExpSetup, cmdline: str, extents: tp.List[ArenaExtent]
+    ) -> None:
+        self.cmdline = cmdline
+        self.extents = extents
+        self.setup = setup
+        self.element_adds = []  # type: tp.List[definition.ElementAddList]
+
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
+        """
+        No effect.
+
+        All tags/attributes are either deleted or added.
+        """
+        return []
+
+    def gen_tag_rmlist(self) -> tp.List[definition.ElementRmList]:
+        """Remove the ``<camera>`` tag if it exists.
+
+        Obviously you *must* call this function BEFORE adding new definitions.
+
+        """
+        return [
+            definition.ElementRmList(
+                definition.ElementRm("./visualization/qt-opengl", "camera")
+            )
+        ]
+
+    def gen_element_addlist(self) -> tp.List[definition.ElementAddList]:
+        if not self.element_adds:
+            adds = definition.ElementAddList(
+                definition.ElementAdd("./visualization/qt-opengl", "camera", {}, False),
+                definition.ElementAdd(
+                    "./visualization/qt-opengl/camera", "placements", {}, False
+                ),
+            )
+
+            in_ticks = self.setup.n_secs_per_run * self.setup.n_ticks_per_sec
+            adds.append(
+                definition.ElementAdd(
+                    ".//qt-opengl/camera", "timeline", {"loop": str(in_ticks)}, False
+                )
+            )
+
+            for ext in self.extents:
+                # generate keyframes for switching between camera perspectives
+                self._gen_keyframes(adds, self.kARGOS_N_CAMERAS, in_ticks)
+
+                info = []
+                for c in range(0, self.kARGOS_N_CAMERAS):
+                    info.append(self._gen_camera_config(ext, c, self.kARGOS_N_CAMERAS))
+
+                for index, up, look_at, pos in info:
+                    camera = definition.ElementAdd(
+                        ".//camera/placements",
+                        "placement",
+                        {
+                            "index": f"{index}",
+                            "up": f"{up.x},{up.y},{up.z}",
+                            "position": f"{pos.x},{pos.y},{pos.z}",
+                            "look_at": f"{look_at.x},{look_at.y},{look_at.z}",
+                        },
+                        True,
+                    )
+                    adds.append(camera)
+
+            self.element_adds = [adds]
+
+        return self.element_adds
+
+    def gen_files(self) -> None:
+        pass
+
+    def _gen_keyframes(
+        self, adds: definition.ElementAddList, n_cameras: int, cycle_length: int
+    ) -> None:
+        for c in range(0, n_cameras):
+            index = c % n_cameras
+            adds.append(
+                definition.ElementAdd(
+                    ".//qt-opengl/camera/timeline",
+                    "keyframe",
+                    {
+                        "placement": str(index),
+                        "step": str(int(cycle_length / n_cameras * c)),
+                    },
+                    True,
+                )
+            )
+            if "interp" in self.cmdline and c < n_cameras:
+                adds.append(
+                    definition.ElementAdd(
+                        ".//qt-opengl/camera/timeline", "interpolate", {}, True
+                    )
+                )
+
+    def _gen_camera_config(self, ext: ArenaExtent, index: int, n_cameras) -> tuple:
+        angle = (index % n_cameras) * (2.0 * math.pi / n_cameras)
+        look_at = Vector3D(ext.xsize() / 2.0, ext.ysize() / 2.0, 0.0)
+        hyp = math.sqrt(2 * max(look_at.x, look_at.y) ** 2)
+
+        pos_x = hyp * math.cos(angle) + look_at.x
+        pos_y = hyp * math.sin(angle) + look_at.y
+        pos_z = max(ext.xsize(), ext.ysize()) * 0.50
+        pos = Vector3D(pos_x, pos_y, pos_z)
+
+        # This is what the ARGoS source does for the up vector for the default
+        # camera configuration
+        up = Vector3D(0, 0, 1)
+
+        return index, up, look_at, pos
+
+
+@implements.implements(IBaseVariable)
+class QTCameraOverhead:
+    """Defines a single overhead camera perspective within ARGoS.
+
+    Attributes:
+        extents: List of (X,Y,Z) tuple of dimensions of arena areas to generate
+                 camera definitions for.
+
+    """
+
+    def __init__(self, extents: tp.List[ArenaExtent]) -> None:
+        self.extents = extents
+        self.element_adds = []  # type: tp.List[definition.ElementAddList]
+
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
+        """No effect.
+
+        All tags/attributes are either deleted or added.
+
+        """
+        return []
+
+    def gen_tag_rmlist(self) -> tp.List[definition.ElementRmList]:
+        """Remove the ``<camera>`` tag if it exists.
+
+        Obviously you *must* call this function BEFORE adding new definitions.
+
+        """
+        return [
+            definition.ElementRmList(
+                definition.ElementRm("./visualization/qt-opengl", "camera")
+            )
+        ]
+
+    def gen_element_addlist(self) -> tp.List[definition.ElementAddList]:
+        if not self.element_adds:
+            adds = definition.ElementAddList(
+                definition.ElementAdd("./visualization/qt-opengl", "camera", {}, False),
+                definition.ElementAdd(
+                    "./visualization/qt-opengl/camera", "placements", {}, False
+                ),
+            )
+
+            for ext in self.extents:
+                height = max(ext.xsize(), ext.ysize()) * 0.75
+                camera = definition.ElementAdd(
+                    ".//camera/placements",
+                    "placement",
+                    {
+                        "index": "0",
+                        "position": "{0}, {1}, {2}".format(
+                            ext.xsize() / 2.0, ext.ysize() / 2.0, height
+                        ),
+                        "look_at": "{0}, {1}, 0".format(
+                            ext.xsize() / 2.0, ext.ysize() / 2.0
+                        ),
+                    },
+                    True,
+                )
+                adds.append(camera)
+            self.element_adds = [adds]
+
+        return self.element_adds
+
+    def gen_files(self) -> None:
+        pass
+
+
+def factory(cmdopts: types.Cmdopts, extents: tp.List[ArenaExtent]):
+    """Create cameras for a list of arena extents."""
+    if cmdopts["camera_config"] == "overhead":
+        return QTCameraOverhead(extents)
+    else:
+        return QTCameraTimeline(
+            exp.factory(cmdopts["exp_setup"]), cmdopts["camera_config"], extents
+        )
+
+
+__all__ = [
+    "QTCameraTimeline",
+    "QTCameraOverhead",
+]

sierra/plugins/engine/argos/variables/constant_density.py

@@ -0,0 +1,112 @@
+# Copyright 2018 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+#
+"""
+Functionality for mapping arena size -> swarm size to maintain a constant ratio.
+"""
+# Core packages
+import re
+import typing as tp
+import pathlib
+
+# 3rd party packages
+
+# Project packages
+from sierra.core.variables import batch_criteria as bc
+from sierra.core.utils import ArenaExtent
+from sierra.plugins.engine.argos.variables.arena_shape import ArenaShape
+from sierra.core import types
+
+
+class ConstantDensity(bc.UnivarBatchCriteria):
+    """Defines common functionality for all constant-density classes.
+
+    Constant density = SOMETHING/arena size is held constant as arena size is
+    increased. This class is a base class which should NEVER be used on its own.
+
+    Attributes:
+        target_density: The target density.
+
+        dimensions: List of (X,Y) dimensions to use (creates rectangular
+                    arenas).
+
+        scenario_tag: A scenario tag (presumably part of `--scenario`) to use to
+                      generate scenario names.
+
+        changes: List of sets of changes to apply to generate the specified
+                 arena sizes.
+
+    """
+
+    def __init__(
+        self,
+        cli_arg: str,
+        main_config: types.YAMLDict,
+        batch_input_root: pathlib.Path,
+        target_density: float,
+        dimensions: tp.List[ArenaExtent],
+        scenario_tag: str,
+    ) -> None:
+        bc.UnivarBatchCriteria.__init__(self, cli_arg, main_config, batch_input_root)
+        self.target_density = target_density
+        self.dimensions = dimensions
+        self.scenario_tag = scenario_tag
+        self.attr_changes = ArenaShape(dimensions).gen_attr_changelist()
+
+    def computable_exp_scenario_name(self) -> bool:
+        return True
+
+    def exp_scenario_name(self, exp_num: int) -> str:
+        """Given the exp number in the batch, compute a parsable scenario name.
+
+        It is necessary to query this criteria after generating the changelist
+        in order to create generator classes for each experiment in the batch
+        with the correct name and definition in some cases.
+
+        Normally controller+scenario are used to look up all necessary changes
+        for the specified arena size, but for this criteria the specified
+        scenario is the base scenario (i.e., the starting arena dimensions), and
+        the correct arena dimensions for a given exp must be found via lookup
+        with THIS function).
+
+        """
+        dims = self.dimensions[exp_num]
+        return (
+            self.scenario_tag
+            + "."
+            + "x".join([str(dims.xsize()), str(dims.ysize()), str(dims.zsize())])
+        )
+
+
+def parse(arg: str) -> types.CLIArgSpec:
+    """Enforces specification of a :class:`ConstantDensity` derived batch criteria.
+
+    Returns:
+       Dict:
+             target_density: Floating point value of parsed target density
+             arena_size_inc: Integer increment for arena size
+    """
+    ret = {}
+
+    sections = arg.split(".")
+    # remove variable name, leaving only the spec
+    spec = ".".join(sections[1:])
+
+    regex = r"(\d+)p(\d+)\.I(\d+)\.C(\d+)"
+    res = re.match(regex, spec)
+
+    assert len(res.groups()) == 4, f"Spec must match {regex}, have {spec}"
+
+    # groups(0) is always the full matched string; subsequent groups are the
+    # captured groups from the () expressions.
+    characteristic = float(res.group(1))
+    mantissa = float("0." + res.group(2))
+    ret["target_density"] = characteristic + mantissa
+    ret["arena_size_inc"] = int(res.group(3))
+    ret["cardinality"] = int(res.group(4))
+
+    return ret
+
+
+__all__ = ["ConstantDensity", "parse"]

sierra/plugins/engine/argos/variables/exp_setup.py

@@ -0,0 +1,82 @@
+# Copyright 2021 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+
+"""Classes for the ``--exp-setup`` cmdline option.
+
+See :ref:`usage/vars/expsetup` for usage documentation.
+
+"""
+
+# Core packages
+import typing as tp
+
+# 3rd party packages
+import implements
+
+# Project packages
+from sierra.core.variables.base_variable import IBaseVariable
+from sierra.core.experiment import definition
+from sierra.core import config
+from sierra.core.variables import exp_setup
+
+
+@implements.implements(IBaseVariable)
+class ExpSetup:
+    """
+    Defines the simulation duration.
+
+    """
+
+    def __init__(self, n_secs_per_run: int, n_ticks_per_sec: int) -> None:
+        self.n_secs_per_run = n_secs_per_run
+        self.n_ticks_per_sec = n_ticks_per_sec
+        self.attr_changes = []  # type: tp.List[definition.AttrChangeSet]
+
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
+        if not self.attr_changes:
+            chgs = definition.AttrChangeSet(
+                definition.AttrChange(
+                    ".//experiment", "length", "{0}".format(self.n_secs_per_run)
+                ),
+                definition.AttrChange(
+                    ".//experiment",
+                    "ticks_per_second",
+                    "{0}".format(self.n_ticks_per_sec),
+                ),
+            )
+            self.attr_changes = [chgs]
+        return self.attr_changes
+
+    def gen_tag_rmlist(self) -> tp.List[definition.ElementRmList]:
+        return []
+
+    def gen_element_addlist(self) -> tp.List[definition.ElementAddList]:
+        return []
+
+    def gen_files(self) -> None:
+        pass
+
+
+def factory(arg: str) -> ExpSetup:
+    """Create an :class:`ExpSetup` derived class from the command line definition.
+
+    Arguments:
+
+       arg: The value of ``--exp-setup``.
+
+    """
+    attr = exp_setup.parse(
+        arg,
+        {
+            "n_secs_per_run": config.kARGoS["n_secs_per_run"],
+            "n_ticks_per_sec": config.kARGoS["n_ticks_per_sec"],
+        },
+    )
+
+    return ExpSetup(attr["n_secs_per_run"], attr["n_ticks_per_sec"])
+
+
+__all__ = [
+    "ExpSetup",
+]