Neodroid  0.2.0
Machine Learning Environment Prototyping Tool
FBSReactionUtilities.cs
Go to the documentation of this file.
1 using System;
2 using System.Collections.Generic;
7 using UnityEngine;
8 
9 namespace droid.Runtime.Messaging.FBS {
12  public static class FbsReactionUtilities {
13  static List<Vector3> _vector_out = new List<Vector3>();
14  static List<float> _float_out = new List<float>();
15  static List<Points.ValuePoint> _output = new List<Points.ValuePoint>();
16 
17  #region PublicMethods
18 
19  static Reaction _null_reaction = new Reaction(null, null, null, null, null, "");
20  static ReactionParameters _null_reaction_parameters = new ReactionParameters();
21  static List<Reaction> _out_reactions = new List<Reaction>();
22 
27  public static Tuple<Reaction[], bool, string, SimulatorConfigurationMessage> deserialise_reactions(
28  FReactions? reactions) {
29  _out_reactions.Clear();
30 
31  var close = false;
32  var api_version = "";
33  var simulator_configuration = new SimulatorConfigurationMessage();
34 
35  if (reactions.HasValue) {
36  var rs = reactions.Value;
37  for (var i = 0; i < rs.ReactionsLength; i++) {
38  _out_reactions.Add(deserialise_reaction(rs.Reactions(i)));
39  }
40 
41  close = rs.Close;
42  api_version = rs.ApiVersion;
43  if (rs.SimulatorConfiguration.HasValue) {
44  simulator_configuration.FbsParse(rs.SimulatorConfiguration.Value);
45  }
46  }
47 
48  if (_out_reactions.Count == 0) {
49  Debug.LogWarning("Empty reactions received");
50  }
51 
52  return new Tuple<Reaction[], bool, String, SimulatorConfigurationMessage>(_out_reactions.ToArray(),
53  close,
54  api_version,
55  simulator_configuration);
56  }
57 
62  public static Reaction deserialise_reaction(FReaction? reaction) {
63  if (reaction.HasValue) {
64  var r = reaction.Value;
65  var motions = deserialise_motions(r);
66  var configurations = deserialise_configurations(r);
67  var displayables = deserialise_displayables(r);
68  var unobservables = deserialise_unobservables(r);
69  var parameters = deserialise_parameters(r);
70  var serialised_message = deserialise_serialised_message(r);
71 
72  return new Reaction(parameters,
73  motions,
74  configurations,
75  unobservables,
76  displayables,
77  serialised_message,
78  r.EnvironmentName);
79  }
80 
81  Debug.LogWarning("Empty reaction received");
82  return _null_reaction;
83  }
84 
85  #endregion
86 
87  #region PrivateMethods
88 
89  static String deserialise_simulator_configuration(FReaction reaction_value) {
90  return reaction_value.SerialisedMessage;
91  }
92 
93  static String deserialise_serialised_message(FReaction reaction_value) {
94  return reaction_value.SerialisedMessage;
95  }
96 
97  static Unobservables deserialise_unobservables(FReaction reaction) {
98  if (reaction.Unobservables.HasValue) {
99  var bodies = deserialise_bodies(reaction.Unobservables.Value);
100 
101  var poses = deserialise_poses(reaction.Unobservables.Value);
102 
103  return new Unobservables(ref bodies, ref poses);
104  }
105 
106  return new Unobservables();
107  }
108 
109  static ReactionParameters deserialise_parameters(FReaction reaction) {
110  if (reaction.Parameters.HasValue) {
111  return new ReactionParameters(reaction.Parameters.Value.Terminable,
112  reaction.Parameters.Value.Step,
113  reaction.Parameters.Value.Reset,
114  reaction.Parameters.Value.Configure,
115  reaction.Parameters.Value.Describe,
116  reaction.Parameters.Value.EpisodeCount);
117  }
118 
119  return _null_reaction_parameters;
120  }
121 
122  static Configuration[] deserialise_configurations(FReaction reaction) {
123  var l = reaction.ConfigurationsLength;
124  var configurations = new Configuration[l];
125  for (var i = 0; i < l; i++) {
126  configurations[i] = deserialise_configuration(reaction.Configurations(i));
127  }
128 
129  return configurations;
130  }
131 
132  static Displayable[] deserialise_displayables(FReaction reaction) {
133  var l = reaction.DisplayablesLength;
134  var configurations = new Displayable[l];
135  for (var i = 0; i < l; i++) {
136  configurations[i] = deserialise_displayable(reaction.Displayables(i));
137  }
138 
139  return configurations;
140  }
141 
142  static Displayable deserialise_displayable(FDisplayable? displayable) {
143  if (displayable.HasValue) {
144  var d = displayable.Value;
145 
146  switch (d.DisplayableValueType) {
147  case FDisplayableValue.NONE: break;
148 
149  case FDisplayableValue.FValue:
150  return new DisplayableFloat(d.DisplayableName, d.DisplayableValue<FValue>()?.Val);
151 
152  case FDisplayableValue.FValues:
153  var v3 = d.DisplayableValue<FValues>().GetValueOrDefault();
154  _float_out.Clear();
155  for (var i = 0; i < v3.ValsLength; i++) {
156  _float_out.Add((float)v3.Vals(i));
157  }
158 
159  return new DisplayableValues(d.DisplayableName, _float_out.ToArray());
160 
161  case FDisplayableValue.FVector3s:
162  var v2 = d.DisplayableValue<FVector3s>().GetValueOrDefault();
163  _vector_out.Clear();
164  for (var i = 0; i < v2.PointsLength; i++) {
165  var p = v2.Points(i).GetValueOrDefault();
166  var v = new Vector3((float)p.X, (float)p.Y, (float)p.Z);
167  _vector_out.Add(v);
168  }
169 
170  return new DisplayableVector3S(d.DisplayableName, _vector_out.ToArray());
171 
172  case FDisplayableValue.FValuedVector3s:
173  var flat_fvec3 = d.DisplayableValue<FValuedVector3s>().GetValueOrDefault();
174  _output.Clear();
175 
176  for (var i = 0; i < flat_fvec3.PointsLength; i++) {
177  var val = (float)flat_fvec3.Vals(i);
178  var p = flat_fvec3.Points(i).GetValueOrDefault();
179  var v = new Points.ValuePoint(new Vector3((float)p.X, (float)p.Y, (float)p.Z), val, 1);
180  _output.Add(v);
181  }
182 
183  return new DisplayableValuedVector3S(d.DisplayableName, _output.ToArray());
184 
185  case FDisplayableValue.FString:
186  return new DisplayableString(d.DisplayableName, d.DisplayableValue<FString>()?.Str);
187 
188  case FDisplayableValue.FByteArray: break;
189  default: throw new ArgumentOutOfRangeException();
190  }
191  }
192 
193  return null;
194  }
195 
196  static IMotion[] deserialise_motions(FReaction reaction) {
197  var l = reaction.MotionsLength;
198  var motions = new IMotion[l];
199  for (var i = 0; i < l; i++) {
200  motions[i] = deserialise_motion(reaction.Motions(i));
201  }
202 
203  return motions;
204  }
205 
206  static Configuration deserialise_configuration(FConfiguration? configuration) {
207  if (configuration.HasValue) {
208  var c = configuration.Value;
209  var sample_random = false; //TODO: c.SampleRandom;
210  return new Configuration(c.ConfigurableName, (float)c.ConfigurableValue, sample_random);
211  }
212 
213  return null;
214  }
215 
216  static ActuatorMotion deserialise_motion(FMotion? motion) {
217  if (motion.HasValue) {
218  return new ActuatorMotion(motion.Value.ActorName,
219  motion.Value.ActuatorName,
220  (float)motion.Value.Strength);
221  }
222 
223  return null;
224  }
225 
226  static Pose[] deserialise_poses(FUnobservables unobservables) {
227  var l = unobservables.PosesLength;
228  var poses = new Pose[l];
229  for (var i = 0; i < l; i++) {
230  poses[i] = deserialise_pose(unobservables.Poses(i));
231  }
232 
233  return poses;
234  }
235 
236  static Body[] deserialise_bodies(FUnobservables unobservables) {
237  var l = unobservables.BodiesLength;
238  var bodies = new Body[l];
239  for (var i = 0; i < l; i++) {
240  bodies[i] = deserialise_body(unobservables.Bodies(i));
241  }
242 
243  return bodies;
244  }
245 
246  static Pose deserialise_pose(FQuaternionTransform? trans) {
247  if (trans.HasValue) {
248  var position = trans.Value.Position;
249  var rotation = trans.Value.Rotation;
250  var vec3_pos = new Vector3((float)position.X, (float)position.Y, (float)position.Z);
251  var quat_rot = new Quaternion((float)rotation.X,
252  (float)rotation.Y,
253  (float)rotation.Z,
254  (float)rotation.W);
255  return new Pose(vec3_pos, quat_rot);
256  }
257 
258  return new Pose();
259  }
260 
261  static Body deserialise_body(FBody? body) {
262  if (body.HasValue) {
263  var vel = body.Value.Velocity;
264  var ang = body.Value.AngularVelocity;
265  var vec3_vel = new Vector3((float)vel.X, (float)vel.Y, (float)vel.Z);
266  var vec3_ang = new Vector3((float)ang.X, (float)ang.Y, (float)ang.Z);
267  return new Body(vec3_vel, vec3_ang);
268  }
269 
270  return null;
271  }
272 
273  #endregion
274  }
275 }
Has a possible direction given by the sign of the float in strength
Definition: MotorMotion.cs:9