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

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

@@ -1,243 +0,0 @@
-# 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 xml
-from sierra.core import types, config
-from sierra.core.vector import Vector3D
-import sierra.plugins.platform.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.tag_adds = []  # type: tp.List[xml.TagAddList]
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        """
-        No effect.
-
-        All tags/attributes are either deleted or added.
-        """
-        return []
-
-    def gen_tag_rmlist(self) -> tp.List[xml.TagRmList]:
-        """Remove the ``<camera>`` tag if it exists.
-
-        Obviously you *must* call this function BEFORE adding new definitions.
-
-        """
-        return [xml.TagRmList(xml.TagRm("./visualization/qt-opengl", "camera"))]
-
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
-        if not self.tag_adds:
-            adds = xml.TagAddList(xml.TagAdd('./visualization/qt-opengl',
-                                             'camera',
-                                             {},
-                                             False),
-                                  xml.TagAdd("./visualization/qt-opengl/camera",
-                                             "placements",
-                                             {},
-                                             False))
-
-            in_ticks = self.setup.n_secs_per_run * self.setup.n_ticks_per_sec
-            adds.append(xml.TagAdd('.//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 = xml.TagAdd('.//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.tag_adds = [adds]
-
-        return self.tag_adds
-
-    def gen_files(self) -> None:
-        pass
-
-    def _gen_keyframes(self,
-                       adds: xml.TagAddList,
-                       n_cameras: int,
-                       cycle_length: int) -> None:
-        for c in range(0, n_cameras):
-            index = c % n_cameras
-            adds.append(xml.TagAdd('.//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(xml.TagAdd('.//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.tag_adds = []  # type: tp.List[xml.TagAddList]
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        """No effect.
-
-        All tags/attributes are either deleted or added.
-
-        """
-        return []
-
-    def gen_tag_rmlist(self) -> tp.List[xml.TagRmList]:
-        """Remove the ``<camera>`` tag if it exists.
-
-        Obviously you *must* call this function BEFORE adding new definitions.
-
-        """
-        return [xml.TagRmList(xml.TagRm("./visualization/qt-opengl", "camera"))]
-
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
-        if not self.tag_adds:
-            adds = xml.TagAddList(xml.TagAdd('./visualization/qt-opengl',
-                                             'camera',
-                                             {},
-                                             False),
-                                  xml.TagAdd("./visualization/qt-opengl/camera",
-                                             "placements",
-                                             {},
-                                             False))
-
-            for ext in self.extents:
-                height = max(ext.xsize(), ext.ysize()) * 0.75
-                camera = xml.TagAdd('.//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.tag_adds = [adds]
-
-        return self.tag_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"])(),  # type: ignore
-                                cmdopts['camera_config'],
-                                extents)
-
-
-__api__ = [
-    'QTCameraTimeline', 'QTCameraOverhead',
-
-
-]

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

@@ -1,136 +0,0 @@
-# Copyright 2018 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-
-# 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.platform.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 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())])
-
-
-class Parser():
-    """Enforces specification of a :class:`ConstantDensity` derived batch criteria.
-
-    """
-
-    def __call__(self, arg: str) -> types.CLIArgSpec:
-        """
-        Parse the cmdline argument.
-
-        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
-        sections = sections[1:]
-
-        # Need to have 2 dot/3 parts
-        assert len(sections) == 3, \
-            (f"Spec must have 3 sections separated by '.'; have "
-             f"{len(sections)} sections from '{arg}'")
-
-        # Parse density
-        res = re.search('[0-9]+', sections[0])
-        assert res is not None, \
-            f"Bad density characteristic spec in section '{sections[0]}'"
-
-        characteristic = float(res.group(0))
-
-        res = re.search('p[0-9]+', sections[0])
-        assert res is not None, \
-            f"Bad density mantissa spec in section '{sections[0]}'"
-        mantissa = float("0." + res.group(0)[1:])
-
-        ret['target_density'] = characteristic + mantissa
-
-        # Parse arena size increment
-        res = re.search('I[0-9]+', sections[1])
-        assert res is not None, \
-            f"Bad arena increment spec in section '{sections[1]}'"
-        ret['arena_size_inc'] = int(res.group(0)[1:])
-
-        # Parse cardinality
-        res = re.search('C[0-9]+', sections[2])
-        assert res is not None, \
-            f"Bad cardinality spec in section '{sections[2]}'"
-
-        ret['cardinality'] = int(res.group(0)[1:])
-
-        return ret
-
-
-__api__ = [
-    'ConstantDensity'
-]

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

@@ -1,113 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-
-"""Classes for the ``--exp-setup`` cmdline option.
-
-See :ref:`ln-sierra-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 xml
-from sierra.core import config, types
-from sierra.core.variables.exp_setup import Parser
-
-
-@implements.implements(IBaseVariable)
-class ExpSetup():
-    """
-    Defines the simulation duration.
-
-    Attributes:
-
-        duration: The simulation duration in seconds, NOT timesteps.
-    """
-    @staticmethod
-    def extract_time_params(exp_def: xml.AttrChangeSet) -> types.IntDict:
-        """
-        Extract and return time parameters for the experiment.
-
-        Returns:
-
-            length (in seconds), ticks_per_second
-        """
-        ret = {
-            'T_in_secs': int(),
-            'n_ticks_per_sec': int()
-        }
-
-        for path, attr, value in exp_def:
-            if 'experiment' in path:
-                if 'length' in attr:
-                    ret['T_in_secs'] = int(value)
-                if 'ticks_per_second' in attr:
-                    ret['n_ticks_per_sec'] = int(value)
-
-        return ret
-
-    def __init__(self,
-                 n_secs_per_run: int,
-                 n_datapoints: int,
-                 n_ticks_per_sec: int) -> None:
-        self.n_secs_per_run = n_secs_per_run
-        self.n_datapoints = n_datapoints
-        self.n_ticks_per_sec = n_ticks_per_sec
-        self.attr_changes = []  # type: tp.List[xml.AttrChangeSet]
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        if not self.attr_changes:
-            chgs = xml.AttrChangeSet(xml.AttrChange(".//experiment",
-                                                    "length",
-                                                    "{0}".format(self.n_secs_per_run)),
-                                     xml.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[xml.TagRmList]:
-        return []
-
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
-        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``.
-
-    """
-    parser = Parser({'n_secs_per_run': config.kARGoS['n_secs_per_run'],
-                     'n_ticks_per_sec': config.kARGoS['n_ticks_per_sec'],
-                     'n_datapoints': config.kExperimentalRunData['n_datapoints_1D']})
-    attr = parser(arg)
-
-    def __init__(self: ExpSetup) -> None:
-        ExpSetup.__init__(self,
-                          attr["n_secs_per_run"],
-                          attr['n_datapoints'],
-                          attr['n_ticks_per_sec'])
-
-    return type(attr['pretty_name'],
-                (ExpSetup,),
-                {"__init__": __init__})  # type: ignore
-
-
-__api__ = [
-    'ExpSetup',
-]

sierra/plugins/platform/argos/variables/population_constant_density.py

@@ -1,175 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-"""Classes for the constant population density batch criteria.
-
-See :ref:`ln-sierra-platform-argos-bc-population-constant-density` for usage
-documentation.
-
-"""
-
-# Core packages
-import typing as tp
-import logging
-import math
-
-# 3rd party packages
-import implements
-
-# Project packages
-from sierra.plugins.platform.argos.variables import constant_density as cd
-from sierra.core import utils, types
-import sierra.core.variables.batch_criteria as bc
-from sierra.core.vector import Vector3D
-from sierra.core.experiment import xml
-
-
-@implements.implements(bc.IConcreteBatchCriteria)
-class PopulationConstantDensity(cd.ConstantDensity):
-    """Defines XML changes for maintain population density across arena sizes.
-
-    This class is a base class which should (almost) never be used on its
-    own. Instead, the ``factory()`` function should be used to dynamically
-    create derived classes expressing the user's desired density.
-
-    Does not change the # blocks/block manifest.
-
-    """
-
-    def __init__(self, *args, **kwargs) -> None:
-        cd.ConstantDensity.__init__(self, *args, **kwargs)
-        self.already_added = False
-        self.logger = logging.getLogger(__name__)
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        """Generate XML modifications to to maintain constant population density.
-
-        Robots are approximated as point masses.
-
-        """
-        if not self.already_added:
-            for changeset in self.attr_changes:
-                for path, attr, value in changeset:
-
-                    if path == ".//arena" and attr == "size":
-                        x, y, z = [int(float(_)) for _ in value.split(",")]
-                        extent = utils.ArenaExtent(
-                            Vector3D(x, y, z))
-                        # ARGoS won't start if there are 0 robots, so you always
-                        # need to put at least 1.
-                        n_robots = int(extent.area() *
-                                       (self.target_density / 100.0))
-                        if n_robots == 0:
-                            n_robots = 1
-                            self.logger.warning(("n_robots set to 1 even though "
-                                                 "calculated as 0 for area=%s,"
-                                                 "density=%s"),
-                                                str(extent.area()),
-                                                self.target_density / 100.0)
-
-                        changeset.add(xml.AttrChange(".//arena/distribute/entity",
-                                                     "quantity",
-                                                     str(n_robots)))
-                        self.logger.debug("Calculated population size=%d for extent=%s,density=%s",
-                                          n_robots,
-                                          str(extent), self.target_density)
-                        break
-
-            self.already_added = True
-
-        return self.attr_changes
-
-    def gen_exp_names(self, cmdopts: types.Cmdopts) -> tp.List[str]:
-        changes = self.gen_attr_changelist()
-        return ['exp' + str(x) for x in range(0, len(changes))]
-
-    def graph_xticks(self,
-                     cmdopts: types.Cmdopts,
-                     exp_names: tp.Optional[tp.List[str]] = None) -> tp.List[float]:
-
-        if exp_names is None:
-            exp_names = self.gen_exp_names(cmdopts)
-
-        ret = list(map(float, self.populations(cmdopts, exp_names)))
-
-        if cmdopts['plot_log_xscale']:
-            return [int(math.log2(x)) for x in ret]
-        elif cmdopts['plot_enumerated_xscale']:
-            return list(range(0, len(ret)))
-        else:
-            return ret
-
-    def graph_xticklabels(self,
-                          cmdopts: types.Cmdopts,
-                          exp_names: tp.Optional[tp.List[str]] = None) -> tp.List[str]:
-        if exp_names is None:
-            exp_names = self.gen_exp_names(cmdopts)
-
-        ret = map(float, self.populations(cmdopts, exp_names))
-
-        return list(map(lambda x: str(int(round(x, 4))), ret))
-
-    def graph_xlabel(self, cmdopts: types.Cmdopts) -> str:
-        if cmdopts['plot_log_xscale']:
-            return r"$\log_{2}$(Population Size)"
-
-        return r"Population Size"
-
-    def n_robots(self, exp_num: int) -> int:
-        return int(self.target_density / 100.0 * self.dimensions[exp_num].area())
-
-
-def calc_dims(cmdopts: types.Cmdopts,
-              attr: types.CLIArgSpec,
-              **kwargs) -> tp.List[utils.ArenaExtent]:
-
-    kw = utils.gen_scenario_spec(cmdopts, **kwargs)
-
-    is_2x1 = kw['arena_x'] == 2 * kw['arena_y']
-    is_1x1 = kw['arena_x'] == kw['arena_y']
-
-    if is_2x1:
-        r = range(kw['arena_x'],
-                  kw['arena_x'] + attr['cardinality'] * attr['arena_size_inc'],
-                  attr['arena_size_inc'])
-        return list(utils.ArenaExtent(Vector3D(x, int(x / 2), kw['arena_z'])) for x in r)
-    elif is_1x1:
-        r = range(kw['arena_x'],
-                  kw['arena_x'] + attr['cardinality'] * attr['arena_size_inc'],
-                  attr['arena_size_inc'])
-
-        return list(utils.ArenaExtent(Vector3D(x, x, kw['arena_z'])) for x in r)
-    else:
-        raise NotImplementedError(
-            "Unsupported arena X,Y scaling '{0}': Must be [2x1,1x1]")
-
-
-def factory(cli_arg: str,
-            main_config: types.YAMLDict,
-            cmdopts: types.Cmdopts,
-            **kwargs) -> PopulationConstantDensity:
-    """Create a :class:`PopulationConstantDensity` derived class.
-
-    """
-    attr = cd.Parser()(cli_arg)
-    kw = utils.gen_scenario_spec(cmdopts, **kwargs)
-    dims = calc_dims(cmdopts, attr, **kwargs)
-
-    def __init__(self) -> None:
-        PopulationConstantDensity.__init__(self,
-                                           cli_arg,
-                                           main_config,
-                                           cmdopts['batch_input_root'],
-                                           attr["target_density"],
-                                           dims,
-                                           kw['scenario_tag'])
-
-    return type(cli_arg,  # type: ignore
-                (PopulationConstantDensity,),
-                {"__init__": __init__})
-
-
-__api__ = [
-    'PopulationConstantDensity'
-]