Neodroid  0.2.0
Machine Learning Environment Prototyping Tool
FBSStateUtilities.cs
Go to the documentation of this file.
5 using FlatBuffers;
6 using UnityEngine;
7 
8 namespace droid.Runtime.Messaging.FBS {
11  public static class FbsStateUtilities {
12  static VectorOffset _null_vector_offset = new VectorOffset();
13  static Offset<FUnobservables> _null_unobservables_offset = new Offset<FUnobservables>();
14 
15  #region PublicMethods
16 
26  public static byte[] Serialise(EnvironmentState[] states,
27  SimulatorConfigurationMessage simulator_configuration = null,
28  bool serialise_individual_observables = false,
29  bool do_serialise_unobservables = false,
30  bool do_serialise_aggregated_float_array = false,
31  string api_version = "N/A") {
32  var b = new FlatBufferBuilder(1);
33  var state_offsets = new Offset<FState>[states.Length];
34  var i = 0;
35  foreach (var state in states) {
36  state_offsets[i++] = serialise_state(b,
37  state,
38  serialise_individual_observables,
39  do_serialise_unobservables,
40  do_serialise_aggregated_float_array);
41  }
42 
43  var states_vector_offset = FStates.CreateStatesVector(b, state_offsets);
44 
45  var api_version_offset = b.CreateString(api_version);
46 
47  FStates.StartFStates(b);
48  FStates.AddStates(b, states_vector_offset);
49  FStates.AddApiVersion(b, api_version_offset);
50  FStates.AddSimulatorConfiguration(b, Serialise(b, simulator_configuration));
51  var states_offset = FStates.EndFStates(b);
52 
53  FStates.FinishFStatesBuffer(b, states_offset);
54 
55  return b.SizedByteArray();
56  }
57 
58  #endregion
59 
60  #region PrivateMethods
61 
67  static Offset<FSimulatorConfiguration>
68  Serialise(FlatBufferBuilder b, SimulatorConfigurationMessage configuration) {
69  return FSimulatorConfiguration.CreateFSimulatorConfiguration(b,
70  configuration.Width,
71  configuration.Height,
72  configuration.FullScreen,
73  configuration.QualityLevel,
74  configuration.TimeScale,
75  configuration.TargetFrameRate,
76  (FSimulationType)configuration
78  configuration.FrameSkips,
79  configuration.ResetIterations,
80  configuration.NumOfEnvironments,
81  configuration.DoSerialiseIndividualSensors,
82  configuration.DoSerialiseUnobservables
83  //TODO: ,configuration.DoSerialiseAggregatedFloatArray
84  );
85  }
86 
95  static Offset<FState> serialise_state(FlatBufferBuilder b,
96  EnvironmentState state,
97  bool serialise_individual_observables = false,
98  bool do_serialise_unobservables = false,
99  bool do_serialise_aggregated_float_array = false) {
100  var n = b.CreateString(state.EnvironmentName);
101 
102  var observables_vector = _null_vector_offset;
103  if (do_serialise_aggregated_float_array) {
104  observables_vector = FState.CreateObservablesVector(b, state.Observables);
105  }
106 
107  var observers_vector = _null_vector_offset;
108  if (serialise_individual_observables) {
109  var observations = state.Observers;
110 
111  var observers = new Offset<FOBS>[observations.Length];
112  var k = 0;
113  foreach (var observer in observations) {
114  observers[k++] = Serialise(b, observer);
115  }
116 
117  observers_vector = FState.CreateObservationsVector(b, observers);
118  }
119 
120  var unobservables = _null_unobservables_offset;
121  if (do_serialise_unobservables) {
122  var state_unobservables = state.Unobservables;
123  var bodies = state_unobservables.Bodies;
124 
125  FUnobservables.StartBodiesVector(b, bodies.Length);
126  foreach (var rig in bodies) {
127  var vel = rig.Velocity;
128  var ang = rig.AngularVelocity;
129  FBody.CreateFBody(b, vel.x, vel.y, vel.z, ang.x, ang.y, ang.z);
130  }
131 
132  var bodies_vector = b.EndVector();
133 
134  var poses = state_unobservables.Poses;
135 
136  FUnobservables.StartPosesVector(b, poses.Length);
137  foreach (var tra in poses) {
138  var pos = tra.position;
139  var rot = tra.rotation;
140  FQuaternionTransform.CreateFQuaternionTransform(b, pos.x, pos.y, pos.z, rot.x, rot.y, rot.z, rot.w);
141  }
142 
143  var poses_vector = b.EndVector();
144 
145  FUnobservables.StartFUnobservables(b);
146  FUnobservables.AddPoses(b, poses_vector);
147  FUnobservables.AddBodies(b, bodies_vector);
148  unobservables = FUnobservables.EndFUnobservables(b);
149  }
150 
151  var description_offset = new Offset<FEnvironmentDescription>();
152  if (state.Description != null) {
153  description_offset = Serialise(b, state);
154  }
155 
156  var d = new StringOffset();
157  if (state.DebugMessage != "") {
158  d = b.CreateString(state.DebugMessage);
159  }
160 
161  var t = b.CreateString(state.TerminationReason);
162 
163  FState.StartFState(b);
164  FState.AddEnvironmentName(b, n);
165 
166  FState.AddFrameNumber(b, state.FrameNumber);
167  if (do_serialise_aggregated_float_array) {
168  FState.AddObservables(b, observables_vector);
169  }
170 
171  if (do_serialise_unobservables) {
172  FState.AddUnobservables(b, unobservables);
173  }
174 
175  FState.AddTotalEnergySpent(b, state.TotalEnergySpentSinceReset);
176  FState.AddSignal(b, state.Signal);
177 
178  FState.AddTerminated(b, state.Terminated);
179  FState.AddTerminationReason(b, t);
180 
181  if (serialise_individual_observables) {
182  FState.AddObservations(b, observers_vector);
183  }
184 
185  if (state.Description != null) {
186  FState.AddEnvironmentDescription(b, description_offset);
187  }
188 
189  if (state.DebugMessage != "") {
190  FState.AddSerialisedMessage(b, d);
191  }
192 
193  return FState.EndFState(b);
194  }
195 
196  static Offset<FActuator> Serialise(FlatBufferBuilder b, IActuator actuator, string identifier) {
197  var n = b.CreateString(identifier);
198  FActuator.StartFActuator(b);
199  FActuator.AddActuatorName(b, n);
200  FActuator.AddValidInput(b,
201  FRange.CreateFRange(b,
202  actuator.MotionSpace._Decimal_Granularity,
203  actuator.MotionSpace._Max_Value,
204  actuator.MotionSpace._Min_Value));
205  FActuator.AddEnergySpentSinceReset(b, actuator.GetEnergySpend());
206  return FActuator.EndFActuator(b);
207  }
208 
214  static Offset<FEulerTransform> Serialise(FlatBufferBuilder b, IHasEulerTransform observer) {
215  Vector3 pos = observer.Position, rot = observer.Rotation, dir = observer.Direction;
216  return FEulerTransform.CreateFEulerTransform(b,
217  pos.x,
218  pos.y,
219  pos.z,
220  rot.x,
221  rot.y,
222  rot.z,
223  dir.x,
224  dir.y,
225  dir.z);
226  }
227 
233  static Offset<FQT> Serialise(FlatBufferBuilder b, IHasQuaternionTransform observer) {
234  var pos = observer.Position;
235  var rot = observer.Rotation;
236  FQT.StartFQT(b);
237  FQT.AddTransform(b,
238  FQuaternionTransform.CreateFQuaternionTransform(b,
239  pos.x,
240  pos.y,
241  pos.z,
242  rot.x,
243  rot.y,
244  rot.z,
245  rot.w));
246  return FQT.EndFQT(b);
247  }
248 
249  static Offset<FByteArray> Serialise(FlatBufferBuilder b, IHasByteArray observer) {
250  var v_offset = FByteArray.CreateBytesVectorBlock(b, observer.Bytes);
251  //var v_offset = CustomFlatBufferImplementation.CreateByteVector(b, camera.Bytes);
252  FByteDataType a;
253  switch (observer.ArrayEncoding) {
254  case "UINT8":
255  a = FByteDataType.UINT8;
256  break;
257  case "FLOAT16":
258  a = FByteDataType.FLOAT16;
259  break;
260  case "FLOAT32":
261  a = FByteDataType.FLOAT32;
262  break;
263  case "JPEG":
264  a = FByteDataType.JPEG;
265  break;
266  case "PNG":
267  a = FByteDataType.PNG;
268  break;
269  default:
270  a = FByteDataType.Other;
271  break;
272  }
273 
274  var c = FByteArray.CreateShapeVector(b, observer.Shape);
275 
276  FByteArray.StartFByteArray(b);
277  FByteArray.AddType(b, a);
278  FByteArray.AddShape(b, c);
279  FByteArray.AddBytes(b, v_offset);
280  return FByteArray.EndFByteArray(b);
281  }
282 
283  static Offset<FArray> Serialise(FlatBufferBuilder b, IHasFloatArray float_a) {
284  var v_offset = FArray.CreateArrayVectorBlock(b, float_a.ObservationArray);
285  //var v_offset = CustomFlatBufferImplementation.CreateFloatVector(b, float_a.ObservationArray);
286 
287  var ranges_vector = new VectorOffset();
288 
289  FArray.StartRangesVector(b, float_a.ObservationSpace.Length);
290  foreach (var tra in float_a.ObservationSpace) {
291  FRange.CreateFRange(b, tra._Decimal_Granularity, tra._Max_Value, tra._Min_Value);
292  }
293 
294  ranges_vector = b.EndVector();
295 
296  FArray.StartFArray(b);
297  FArray.AddArray(b, v_offset);
298 
299  FArray.AddRanges(b, ranges_vector);
300 
301  return FArray.EndFArray(b);
302  }
303 
310  static Offset<FRB> Serialise(FlatBufferBuilder b, Vector3 vel, Vector3 ang) {
311  FRB.StartFRB(b);
312  FRB.AddBody(b, FBody.CreateFBody(b, vel.x, vel.y, vel.z, ang.x, ang.y, ang.z));
313  return FRB.EndFRB(b);
314  }
315 
316  static Offset<FSingle> Serialise(FlatBufferBuilder b, IHasSingle numeral) {
317  FSingle.StartFSingle(b);
318  FSingle.AddValue(b, numeral.ObservationValue);
319 
320  var range_offset = FRange.CreateFRange(b,
321  numeral.SingleSpace._Decimal_Granularity,
322  numeral.SingleSpace._Max_Value,
323  numeral.SingleSpace._Min_Value);
324  FSingle.AddRange(b, range_offset);
325  return FSingle.EndFSingle(b);
326  }
327 
328  static Offset<FDouble> Serialise(FlatBufferBuilder b, IHasDouble numeral) {
329  FDouble.StartFDouble(b);
330  var vec2 = numeral.ObservationValue;
331 
332  var granularity = numeral.DoubleSpace.DecimalGranularity;
333  var xs = numeral.DoubleSpace.Xspace;
334  var ys = numeral.DoubleSpace.Yspace;
335 
336  FDouble.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
337  FDouble.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
338  FDouble.AddVec2(b, FVector2.CreateFVector2(b, vec2.x, vec2.y));
339 
340  return FDouble.EndFDouble(b);
341  }
342 
343  static Offset<FTriple> Serialise(FlatBufferBuilder b, IHasTriple numeral) {
344  FTriple.StartFTriple(b);
345  var vec3 = numeral.ObservationValue;
346 
347  FTriple.AddVec3(b, FVector3.CreateFVector3(b, vec3.x, vec3.y, vec3.z));
348  var granularity = numeral.TripleSpace.DecimalGranularity;
349  var xs = numeral.TripleSpace.Xspace;
350  var ys = numeral.TripleSpace.Yspace;
351  var zs = numeral.TripleSpace.Zspace;
352  FTriple.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
353  FTriple.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
354  FTriple.AddZRange(b, FRange.CreateFRange(b, granularity, zs._Max_Value, zs._Min_Value));
355  return FTriple.EndFTriple(b);
356  }
357 
358  static Offset<FQuadruple> Serialise(FlatBufferBuilder b, IHasQuadruple numeral) {
359  FQuadruple.StartFQuadruple(b);
360  var quad = numeral.ObservationValue;
361  FQuadruple.AddQuat(b, FQuaternion.CreateFQuaternion(b, quad.x, quad.y, quad.z, quad.z));
362  var granularity = numeral.QuadSpace.DecimalGranularity;
363  var xs = numeral.QuadSpace.Xspace;
364  var ys = numeral.QuadSpace.Yspace;
365  var zs = numeral.QuadSpace.Zspace;
366  var ws = numeral.QuadSpace.Wspace;
367  FQuadruple.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
368  FQuadruple.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
369  FQuadruple.AddZRange(b, FRange.CreateFRange(b, granularity, zs._Max_Value, zs._Min_Value));
370  FQuadruple.AddWRange(b, FRange.CreateFRange(b, granularity, ws._Max_Value, ws._Min_Value));
371  return FQuadruple.EndFQuadruple(b);
372  }
373 
374  static Offset<FString> Serialise(FlatBufferBuilder b, IHasString numeral) {
375  var string_offset = b.CreateString(numeral.ObservationValue);
376  FString.StartFString(b);
377  FString.AddStr(b, string_offset);
378 
379  return FString.EndFString(b);
380  }
381 
382  static Offset<FActor> Serialise(FlatBufferBuilder b,
383  Offset<FActuator>[] actuators,
384  IActor actor,
385  string identifier) {
386  var n = b.CreateString(identifier);
387  var actuator_vector = FActor.CreateActuatorsVector(b, actuators);
388  FActor.StartFActor(b);
389  if (actor is KillableActor) {
390  FActor.AddAlive(b, ((KillableActor)actor).IsAlive);
391  } else {
392  FActor.AddAlive(b, true);
393  }
394 
395  FActor.AddActorName(b, n);
396  FActor.AddActuators(b, actuator_vector);
397  return FActor.EndFActor(b);
398  }
399 
400  static Offset<FOBS> Serialise(FlatBufferBuilder b, IObserver observer) {
401  var n = b.CreateString(observer.Identifier);
402 
403  int observation_offset;
404  FObservation observation_type;
405  switch (observer) {
406  case IHasString numeral:
407  observation_offset = Serialise(b, numeral).Value;
408  observation_type = FObservation.FString;
409  break;
410  case IHasFloatArray a:
411  observation_offset = Serialise(b, a).Value;
412  observation_type = FObservation.FArray;
413  break;
414  case IHasSingle single:
415  observation_offset = Serialise(b, single).Value;
416  observation_type = FObservation.FSingle;
417  break;
418  case IHasDouble has_double:
419  observation_offset = Serialise(b, has_double).Value;
420  observation_type = FObservation.FDouble;
421  break;
422  case IHasTriple triple:
423  observation_offset = Serialise(b, triple).Value;
424  observation_type = FObservation.FTriple;
425  break;
426  case IHasQuadruple quadruple:
427  observation_offset = Serialise(b, quadruple).Value;
428  observation_type = FObservation.FQuadruple;
429  break;
430  case IHasEulerTransform transform:
431  observation_offset = Serialise(b, transform).Value;
432  observation_type = FObservation.FET;
433  break;
434  case IHasQuaternionTransform quaternion_transform:
435  observation_offset = Serialise(b, quaternion_transform).Value;
436  observation_type = FObservation.FQT;
437  break;
438  case IHasRigidbody rigidbody:
439  observation_offset = Serialise(b, rigidbody.Velocity, rigidbody.AngularVelocity).Value;
440  observation_type = FObservation.FRB;
441  break;
442  case IHasByteArray array:
443  observation_offset = Serialise(b, array).Value;
444  observation_type = FObservation.FByteArray;
445  break;
446  default:
447  return FOBS.CreateFOBS(b, n);
448  }
449 
450  FOBS.StartFOBS(b);
451  FOBS.AddObservationName(b, n);
452  FOBS.AddObservationType(b, observation_type);
453  FOBS.AddObservation(b, observation_offset);
454  return FOBS.EndFOBS(b);
455  }
456 
457  static Offset<FEnvironmentDescription> Serialise(FlatBufferBuilder b, EnvironmentState state) {
458  var actors_offsets = new Offset<FActor>[state.Description.Actors.Values.Count];
459  var j = 0;
460  foreach (var actor in state.Description.Actors) {
461  var actuators_offsets = new Offset<FActuator>[actor.Value.Actuators.Values.Count];
462  var i = 0;
463  foreach (var actuator in actor.Value.Actuators) {
464  actuators_offsets[i++] = Serialise(b, actuator.Value, actuator.Key);
465  }
466 
467  actors_offsets[j++] = Serialise(b, actuators_offsets, actor.Value, actor.Key);
468  }
469 
470  var actors_vector_offset = FEnvironmentDescription.CreateActorsVector(b, actors_offsets);
471 
472  var configurables_offsets = new Offset<FConfigurable>[state.Description.Configurables.Values.Count];
473  var k = 0;
474  foreach (var configurable in state.Description.Configurables) {
475  configurables_offsets[k++] = Serialise(b, configurable.Value, configurable.Key);
476  }
477 
478  var configurables_vector_offset =
479  FEnvironmentDescription.CreateConfigurablesVector(b, configurables_offsets);
480 
481  var objective_offset = Serialise(b, state.Description);
482 
483  FEnvironmentDescription.StartFEnvironmentDescription(b);
484  FEnvironmentDescription.AddObjective(b, objective_offset);
485 
486  FEnvironmentDescription.AddActors(b, actors_vector_offset);
487  FEnvironmentDescription.AddConfigurables(b, configurables_vector_offset);
488 
489  return FEnvironmentDescription.EndFEnvironmentDescription(b);
490  }
491 
492  static Offset<FObjective> Serialise(FlatBufferBuilder b, EnvironmentDescription description) {
493  var objective_name_offset = b.CreateString("Default objective");
494  FObjective.StartFObjective(b);
495  FObjective.AddMaxEpisodeLength(b, description.MaxSteps);
496  FObjective.AddSolvedThreshold(b, description.SolvedThreshold);
497  FObjective.AddObjectiveName(b, objective_name_offset);
498  return FObjective.EndFObjective(b);
499  }
500 
501  static Offset<FTriple> Serialise(FlatBufferBuilder b, PositionConfigurable observer) {
502  var pos = observer.ObservationValue;
503  FTriple.StartFTriple(b);
504  FTriple.AddVec3(b, FVector3.CreateFVector3(b, pos.x, pos.y, pos.z));
505  return FTriple.EndFTriple(b);
506  }
507 
508  static Offset<FConfigurable> Serialise(
509  FlatBufferBuilder b,
510  IConfigurable configurable,
511  string identifier) {
512  var n = b.CreateString(identifier);
513 
514  int observation_offset;
515  FObservation observation_type;
516 
517  if (configurable is IHasQuaternionTransform) {
518  observation_offset = Serialise(b, (IHasQuaternionTransform)configurable).Value;
519  observation_type = FObservation.FQT;
520  } else if (configurable is PositionConfigurable) {
521  observation_offset = Serialise(b, (PositionConfigurable)configurable).Value;
522  observation_type = FObservation.FTriple;
523  } else if (configurable is IHasSingle) {
524  observation_offset = Serialise(b, (IHasSingle)configurable).Value;
525  observation_type = FObservation.FSingle;
526  // ReSharper disable once SuspiciousTypeConversion.Global
527  } else if (configurable is IHasDouble) {
528  // ReSharper disable once SuspiciousTypeConversion.Global
529  observation_offset = Serialise(b, (IHasDouble)configurable).Value;
530  observation_type = FObservation.FDouble;
531  } else if (configurable is EulerTransformConfigurable) {
532  observation_offset = Serialise(b, (IHasEulerTransform)configurable).Value;
533  observation_type = FObservation.FET;
534  } else {
535  FConfigurable.StartFConfigurable(b);
536  FConfigurable.AddConfigurableName(b, n);
537  return FConfigurable.EndFConfigurable(b);
538  }
539 
540  FConfigurable.StartFConfigurable(b);
541  FConfigurable.AddConfigurableName(b, n);
542  FConfigurable.AddObservation(b, observation_offset);
543  FConfigurable.AddObservationType(b, observation_type);
544  return FConfigurable.EndFConfigurable(b);
545  }
546 
547  #endregion
548  }
549 }