Ejemplo n.º 1
0
        /// <summary>
        /// Create a GridSensorBase with the specified configuration.
        /// </summary>
        /// <param name="name">The sensor name</param>
        /// <param name="cellScale">The scale of each cell in the grid</param>
        /// <param name="gridSize">Number of cells on each side of the grid</param>
        /// <param name="detectableTags">Tags to be detected by the sensor</param>
        /// <param name="compression">Compression type</param>
        public GridSensorBase(
            string name,
            Vector3 cellScale,
            Vector3Int gridSize,
            string[] detectableTags,
            SensorCompressionType compression
            )
        {
            m_Name           = name;
            m_CellScale      = cellScale;
            m_GridSize       = gridSize;
            m_DetectableTags = detectableTags;
            CompressionType  = compression;

            if (m_GridSize.y != 1)
            {
                throw new UnityAgentsException("GridSensor only supports 2D grids.");
            }

            m_NumCells            = m_GridSize.x * m_GridSize.z;
            m_CellObservationSize = GetCellObservationSize();
            m_ObservationSpec     = ObservationSpec.Visual(m_GridSize.x, m_GridSize.z, m_CellObservationSize);
            m_PerceptionTexture   = new Texture2D(m_GridSize.x, m_GridSize.z, TextureFormat.RGB24, false);

            ResetPerceptionBuffer();
        }
 /// <summary>
 /// Creates the BufferSensor.
 /// </summary>
 /// <param name="maxNumberObs">The maximum number of observations to be appended to this BufferSensor.</param>
 /// <param name="obsSize">The size of each observation appended to the BufferSensor.</param>
 /// <param name="name">The name of the sensor.</param>
 public BufferSensor(int maxNumberObs, int obsSize, string name)
 {
     m_Name                  = name;
     m_MaxNumObs             = maxNumberObs;
     m_ObsSize               = obsSize;
     m_ObservationBuffer     = new float[m_ObsSize * m_MaxNumObs];
     m_CurrentNumObservables = 0;
     m_ObservationSpec       = ObservationSpec.VariableLength(m_MaxNumObs, m_ObsSize);
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Initializes the sensor.
        /// </summary>
        /// <param name="observationSize">Number of vector observations.</param>
        /// <param name="name">Name of the sensor.</param>
        public VectorSensor(int observationSize, string name = null)
        {
            if (name == null)
            {
                name = $"VectorSensor_size{observationSize}";
            }

            m_Observations    = new List <float>(observationSize);
            m_Name            = name;
            m_ObservationSpec = ObservationSpec.Vector(observationSize);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Initializes the sensor.
        /// </summary>
        /// <param name="renderTexture">The [RenderTexture](https://docs.unity3d.com/ScriptReference/RenderTexture.html)
        /// instance to wrap.</param>
        /// <param name="grayscale">Whether to convert it to grayscale or not.</param>
        /// <param name="name">Name of the sensor.</param>
        /// <param name="compressionType">Compression method for the render texture.</param>
        /// [GameObject]: https://docs.unity3d.com/Manual/GameObjects.html
        public RenderTextureSensor(
            RenderTexture renderTexture, bool grayscale, string name, SensorCompressionType compressionType)
        {
            m_RenderTexture = renderTexture;
            var width  = renderTexture != null ? renderTexture.width : 0;
            var height = renderTexture != null ? renderTexture.height : 0;

            m_Grayscale       = grayscale;
            m_Name            = name;
            m_ObservationSpec = ObservationSpec.Visual(height, width, grayscale ? 1 : 3);
            m_CompressionType = compressionType;
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Creates and returns the camera sensor.
        /// </summary>
        /// <param name="camera">Camera object to capture images from.</param>
        /// <param name="width">The width of the generated visual observation.</param>
        /// <param name="height">The height of the generated visual observation.</param>
        /// <param name="grayscale">Whether to convert the generated image to grayscale or keep color.</param>
        /// <param name="name">The name of the camera sensor.</param>
        /// <param name="compression">The compression to apply to the generated image.</param>
        /// <param name="observationType">The type of observation.</param>
        public CameraSensor(
            Camera camera, int width, int height, bool grayscale, string name, SensorCompressionType compression, ObservationType observationType = ObservationType.Default)
        {
            m_Camera    = camera;
            m_Width     = width;
            m_Height    = height;
            m_Grayscale = grayscale;
            m_Name      = name;
            var channels = grayscale ? 1 : 3;

            m_ObservationSpec = ObservationSpec.Visual(height, width, channels, observationType);
            m_CompressionType = compression;
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Initializes the sensor.
        /// </summary>
        /// <param name="observationSize">Number of vector observations.</param>
        /// <param name="name">Name of the sensor.</param>
        public VectorSensor(int observationSize, string name = null, ObservationType observationType = ObservationType.Default)
        {
            if (string.IsNullOrEmpty(name))
            {
                name = $"VectorSensor_size{observationSize}";
                if (observationType != ObservationType.Default)
                {
                    name += $"_{observationType.ToString()}";
                }
            }

            m_Observations    = new List <float>(observationSize);
            m_Name            = name;
            m_ObservationSpec = ObservationSpec.Vector(observationSize, observationType);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Initializes the sensor.
        /// </summary>
        /// <param name="wrapped">The wrapped sensor.</param>
        /// <param name="numStackedObservations">Number of stacked observations to keep.</param>
        public StackingSensor(ISensor wrapped, int numStackedObservations)
        {
            // TODO ensure numStackedObservations > 1
            m_WrappedSensor          = wrapped;
            m_NumStackedObservations = numStackedObservations;

            m_Name = $"StackingSensor_size{numStackedObservations}_{wrapped.GetName()}";

            m_WrappedSpec = wrapped.GetObservationSpec();

            m_UnstackedObservationSize = wrapped.ObservationSize();

            // Set up the cached observation spec for the StackingSensor
            var newShape = m_WrappedSpec.Shape;

            // TODO support arbitrary stacking dimension
            newShape[newShape.Length - 1] *= numStackedObservations;
            m_ObservationSpec              = new ObservationSpec(
                newShape, m_WrappedSpec.DimensionProperties, m_WrappedSpec.ObservationType
                );

            // Initialize uncompressed buffer anyway in case python trainer does not
            // support the compression mapping and has to fall back to uncompressed obs.
            m_StackedObservations = new float[numStackedObservations][];
            for (var i = 0; i < numStackedObservations; i++)
            {
                m_StackedObservations[i] = new float[m_UnstackedObservationSize];
            }

            if (m_WrappedSensor.GetCompressionSpec().SensorCompressionType != SensorCompressionType.None)
            {
                m_StackedCompressedObservations = new byte[numStackedObservations][];
                m_EmptyCompressedObservation    = CreateEmptyPNG();
                for (var i = 0; i < numStackedObservations; i++)
                {
                    m_StackedCompressedObservations[i] = m_EmptyCompressedObservation;
                }
                m_CompressionMapping = ConstructStackedCompressedChannelMapping(wrapped);
            }

            if (m_WrappedSpec.Rank != 1)
            {
                var wrappedShape = m_WrappedSpec.Shape;
                m_tensorShape = new TensorShape(0, wrappedShape[0], wrappedShape[1], wrappedShape[2]);
            }
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Set the writer to write to an IList at the given channelOffset.
 /// </summary>
 /// <param name="data">Float array or list that will be written to.</param>
 /// <param name="observationSpec">ObservationSpec of the observation to be written</param>
 /// <param name="offset">Offset from the start of the float data to write to.</param>
 internal void SetTarget(IList <float> data, ObservationSpec observationSpec, int offset)
 {
     SetTarget(data, observationSpec.Shape, offset);
 }
Ejemplo n.º 9
0
 void SetNumObservations(int numObservations)
 {
     m_ObservationSpec = ObservationSpec.Vector(numObservations);
     m_Observations    = new float[numObservations];
 }