casymda - pypi Package Compare versions

Comparing version 0.2.25 to 0.2.26

src/casymda/visualization/web_server/csa_generated.js

+// automatically generated by the FlatBuffers compiler, do not modify
+console.log("csa_generated.js loaded");
+
+/**
+ * @const
+ * @namespace
+ */
+var casymda = casymda || {};
+
+/**
+ * @const
+ * @namespace
+ */
+casymda.visualization = casymda.visualization || {};
+
+/**
+ * @const
+ * @namespace
+ */
+casymda.visualization.web_server = casymda.visualization.web_server || {};
+
+/**
+ * @const
+ * @namespace
+ */
+casymda.visualization.web_server.flatbuffers =
+  casymda.visualization.web_server.flatbuffers || {};
+
+/**
+ * @enum {number}
+ */
+casymda.visualization.web_server.flatbuffers.ElementsUnion = {
+  NONE: 0,
+  Photo: 1,
+  Image: 2,
+  Text: 3,
+};
+
+/**
+ * @enum {string}
+ */
+casymda.visualization.web_server.flatbuffers.ElementsUnionName = {
+  0: "NONE",
+  1: "Photo",
+  2: "Image",
+  3: "Text",
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Canvas = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Canvas}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Canvas=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Canvas}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.getRootAsCanvas = function (
+  bb,
+  obj
+) {
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Canvas()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Canvas=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Canvas}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.getSizePrefixedRootAsCanvas = function (
+  bb,
+  obj
+) {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Canvas()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {number} index
+ * @param {casymda.visualization.web_server.flatbuffers.Element=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Element}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.prototype.content = function (
+  index,
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset
+    ? (
+        obj || new casymda.visualization.web_server.flatbuffers.Element()
+      ).__init(
+        this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+        this.bb
+      )
+    : null;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.prototype.contentLength = function () {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.startCanvas = function (
+  builder
+) {
+  builder.startObject(1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} contentOffset
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.addContent = function (
+  builder,
+  contentOffset
+) {
+  builder.addFieldOffset(0, contentOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<flatbuffers.Offset>} data
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.createContentVector = function (
+  builder,
+  data
+) {
+  builder.startVector(4, data.length, 4);
+  for (var i = data.length - 1; i >= 0; i--) {
+    builder.addOffset(data[i]);
+  }
+  return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.startContentVector = function (
+  builder,
+  numElems
+) {
+  builder.startVector(4, numElems, 4);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.endCanvas = function (
+  builder
+) {
+  var offset = builder.endObject();
+  return offset;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} offset
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.finishCanvasBuffer = function (
+  builder,
+  offset
+) {
+  builder.finish(offset);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} offset
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.finishSizePrefixedCanvasBuffer = function (
+  builder,
+  offset
+) {
+  builder.finish(offset, undefined, true);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} contentOffset
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Canvas.createCanvas = function (
+  builder,
+  contentOffset
+) {
+  casymda.visualization.web_server.flatbuffers.Canvas.startCanvas(builder);
+  casymda.visualization.web_server.flatbuffers.Canvas.addContent(
+    builder,
+    contentOffset
+  );
+  return casymda.visualization.web_server.flatbuffers.Canvas.endCanvas(builder);
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Element = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Element}
+ */
+casymda.visualization.web_server.flatbuffers.Element.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Element=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Element}
+ */
+casymda.visualization.web_server.flatbuffers.Element.getRootAsElement = function (
+  bb,
+  obj
+) {
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Element()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Element=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Element}
+ */
+casymda.visualization.web_server.flatbuffers.Element.getSizePrefixedRootAsElement = function (
+  bb,
+  obj
+) {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Element()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Element.prototype.id = function () {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {casymda.visualization.web_server.flatbuffers.ElementsUnion}
+ */
+casymda.visualization.web_server.flatbuffers.Element.prototype.elementType = function () {
+  var offset = this.bb.__offset(this.bb_pos, 6);
+  return offset
+    ? /** @type {casymda.visualization.web_server.flatbuffers.ElementsUnion} */ (this.bb.readUint8(
+        this.bb_pos + offset
+      ))
+    : casymda.visualization.web_server.flatbuffers.ElementsUnion.NONE;
+};
+
+/**
+ * @param {flatbuffers.Table} obj
+ * @returns {?flatbuffers.Table}
+ */
+casymda.visualization.web_server.flatbuffers.Element.prototype.element = function (
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 8);
+  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+casymda.visualization.web_server.flatbuffers.Element.startElement = function (
+  builder
+) {
+  builder.startObject(3);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ */
+casymda.visualization.web_server.flatbuffers.Element.addId = function (
+  builder,
+  id
+) {
+  builder.addFieldInt16(0, id, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {casymda.visualization.web_server.flatbuffers.ElementsUnion} elementType
+ */
+casymda.visualization.web_server.flatbuffers.Element.addElementType = function (
+  builder,
+  elementType
+) {
+  builder.addFieldInt8(
+    1,
+    elementType,
+    casymda.visualization.web_server.flatbuffers.ElementsUnion.NONE
+  );
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} elementOffset
+ */
+casymda.visualization.web_server.flatbuffers.Element.addElement = function (
+  builder,
+  elementOffset
+) {
+  builder.addFieldOffset(2, elementOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Element.endElement = function (
+  builder
+) {
+  var offset = builder.endObject();
+  return offset;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ * @param {casymda.visualization.web_server.flatbuffers.ElementsUnion} elementType
+ * @param {flatbuffers.Offset} elementOffset
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Element.createElement = function (
+  builder,
+  id,
+  elementType,
+  elementOffset
+) {
+  casymda.visualization.web_server.flatbuffers.Element.startElement(builder);
+  casymda.visualization.web_server.flatbuffers.Element.addId(builder, id);
+  casymda.visualization.web_server.flatbuffers.Element.addElementType(
+    builder,
+    elementType
+  );
+  casymda.visualization.web_server.flatbuffers.Element.addElement(
+    builder,
+    elementOffset
+  );
+  return casymda.visualization.web_server.flatbuffers.Element.endElement(
+    builder
+  );
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Photo = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Photo}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Photo=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Photo}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.getRootAsPhoto = function (
+  bb,
+  obj
+) {
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Photo()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Photo=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Photo}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.getSizePrefixedRootAsPhoto = function (
+  bb,
+  obj
+) {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Photo()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.prototype.factor = function () {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 1.0;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.prototype.path = function (
+  optionalEncoding
+) {
+  var offset = this.bb.__offset(this.bb_pos, 6);
+  return offset
+    ? this.bb.__string(this.bb_pos + offset, optionalEncoding)
+    : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+casymda.visualization.web_server.flatbuffers.Photo.startPhoto = function (
+  builder
+) {
+  builder.startObject(2);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} factor
+ */
+casymda.visualization.web_server.flatbuffers.Photo.addFactor = function (
+  builder,
+  factor
+) {
+  builder.addFieldFloat32(0, factor, 1.0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} pathOffset
+ */
+casymda.visualization.web_server.flatbuffers.Photo.addPath = function (
+  builder,
+  pathOffset
+) {
+  builder.addFieldOffset(1, pathOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.endPhoto = function (
+  builder
+) {
+  var offset = builder.endObject();
+  return offset;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} factor
+ * @param {flatbuffers.Offset} pathOffset
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Photo.createPhoto = function (
+  builder,
+  factor,
+  pathOffset
+) {
+  casymda.visualization.web_server.flatbuffers.Photo.startPhoto(builder);
+  casymda.visualization.web_server.flatbuffers.Photo.addFactor(builder, factor);
+  casymda.visualization.web_server.flatbuffers.Photo.addPath(
+    builder,
+    pathOffset
+  );
+  return casymda.visualization.web_server.flatbuffers.Photo.endPhoto(builder);
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Image = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Image}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Image=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Image}
+ */
+casymda.visualization.web_server.flatbuffers.Image.getRootAsImage = function (
+  bb,
+  obj
+) {
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Image()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Image=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Image}
+ */
+casymda.visualization.web_server.flatbuffers.Image.getSizePrefixedRootAsImage = function (
+  bb,
+  obj
+) {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Image()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {casymda.visualization.web_server.flatbuffers.CanvasPosition=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.CanvasPosition|null}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.position = function (
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset
+    ? (
+        obj || new casymda.visualization.web_server.flatbuffers.CanvasPosition()
+      ).__init(this.bb_pos + offset, this.bb)
+    : null;
+};
+
+/**
+ * @param {casymda.visualization.web_server.flatbuffers.Anchor=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Anchor|null}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.anchor = function (
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 6);
+  return offset
+    ? (obj || new casymda.visualization.web_server.flatbuffers.Anchor()).__init(
+        this.bb_pos + offset,
+        this.bb
+      )
+    : null;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.photoId = function () {
+  var offset = this.bb.__offset(this.bb_pos, 8);
+  return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.path = function (
+  optionalEncoding
+) {
+  var offset = this.bb.__offset(this.bb_pos, 10);
+  return offset
+    ? this.bb.__string(this.bb_pos + offset, optionalEncoding)
+    : null;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Image.prototype.factor = function () {
+  var offset = this.bb.__offset(this.bb_pos, 12);
+  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 1.0;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+casymda.visualization.web_server.flatbuffers.Image.startImage = function (
+  builder
+) {
+  builder.startObject(5);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} positionOffset
+ */
+casymda.visualization.web_server.flatbuffers.Image.addPosition = function (
+  builder,
+  positionOffset
+) {
+  builder.addFieldStruct(0, positionOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} anchorOffset
+ */
+casymda.visualization.web_server.flatbuffers.Image.addAnchor = function (
+  builder,
+  anchorOffset
+) {
+  builder.addFieldStruct(1, anchorOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} photoId
+ */
+casymda.visualization.web_server.flatbuffers.Image.addPhotoId = function (
+  builder,
+  photoId
+) {
+  builder.addFieldInt16(2, photoId, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} pathOffset
+ */
+casymda.visualization.web_server.flatbuffers.Image.addPath = function (
+  builder,
+  pathOffset
+) {
+  builder.addFieldOffset(3, pathOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} factor
+ */
+casymda.visualization.web_server.flatbuffers.Image.addFactor = function (
+  builder,
+  factor
+) {
+  builder.addFieldFloat32(4, factor, 1.0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Image.endImage = function (
+  builder
+) {
+  var offset = builder.endObject();
+  return offset;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} positionOffset
+ * @param {flatbuffers.Offset} anchorOffset
+ * @param {number} photoId
+ * @param {flatbuffers.Offset} pathOffset
+ * @param {number} factor
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Image.createImage = function (
+  builder,
+  positionOffset,
+  anchorOffset,
+  photoId,
+  pathOffset,
+  factor
+) {
+  casymda.visualization.web_server.flatbuffers.Image.startImage(builder);
+  casymda.visualization.web_server.flatbuffers.Image.addPosition(
+    builder,
+    positionOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Image.addAnchor(
+    builder,
+    anchorOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Image.addPhotoId(
+    builder,
+    photoId
+  );
+  casymda.visualization.web_server.flatbuffers.Image.addPath(
+    builder,
+    pathOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Image.addFactor(builder, factor);
+  return casymda.visualization.web_server.flatbuffers.Image.endImage(builder);
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Text = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Text}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Text=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Text}
+ */
+casymda.visualization.web_server.flatbuffers.Text.getRootAsText = function (
+  bb,
+  obj
+) {
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Text()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {casymda.visualization.web_server.flatbuffers.Text=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Text}
+ */
+casymda.visualization.web_server.flatbuffers.Text.getSizePrefixedRootAsText = function (
+  bb,
+  obj
+) {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (
+    obj || new casymda.visualization.web_server.flatbuffers.Text()
+  ).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {casymda.visualization.web_server.flatbuffers.CanvasPosition=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.CanvasPosition|null}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.position = function (
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 4);
+  return offset
+    ? (
+        obj || new casymda.visualization.web_server.flatbuffers.CanvasPosition()
+      ).__init(this.bb_pos + offset, this.bb)
+    : null;
+};
+
+/**
+ * @param {casymda.visualization.web_server.flatbuffers.Anchor=} obj
+ * @returns {casymda.visualization.web_server.flatbuffers.Anchor|null}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.anchor = function (
+  obj
+) {
+  var offset = this.bb.__offset(this.bb_pos, 6);
+  return offset
+    ? (obj || new casymda.visualization.web_server.flatbuffers.Anchor()).__init(
+        this.bb_pos + offset,
+        this.bb
+      )
+    : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.text = function (
+  optionalEncoding
+) {
+  var offset = this.bb.__offset(this.bb_pos, 8);
+  return offset
+    ? this.bb.__string(this.bb_pos + offset, optionalEncoding)
+    : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.fill = function (
+  optionalEncoding
+) {
+  var offset = this.bb.__offset(this.bb_pos, 10);
+  return offset
+    ? this.bb.__string(this.bb_pos + offset, optionalEncoding)
+    : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.fontFamily = function (
+  optionalEncoding
+) {
+  var offset = this.bb.__offset(this.bb_pos, 12);
+  return offset
+    ? this.bb.__string(this.bb_pos + offset, optionalEncoding)
+    : null;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Text.prototype.fontSize = function () {
+  var offset = this.bb.__offset(this.bb_pos, 14);
+  return offset ? this.bb.readUint8(this.bb_pos + offset) : 10;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+casymda.visualization.web_server.flatbuffers.Text.startText = function (
+  builder
+) {
+  builder.startObject(6);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} positionOffset
+ */
+casymda.visualization.web_server.flatbuffers.Text.addPosition = function (
+  builder,
+  positionOffset
+) {
+  builder.addFieldStruct(0, positionOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} anchorOffset
+ */
+casymda.visualization.web_server.flatbuffers.Text.addAnchor = function (
+  builder,
+  anchorOffset
+) {
+  builder.addFieldStruct(1, anchorOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} textOffset
+ */
+casymda.visualization.web_server.flatbuffers.Text.addText = function (
+  builder,
+  textOffset
+) {
+  builder.addFieldOffset(2, textOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} fillOffset
+ */
+casymda.visualization.web_server.flatbuffers.Text.addFill = function (
+  builder,
+  fillOffset
+) {
+  builder.addFieldOffset(3, fillOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} fontFamilyOffset
+ */
+casymda.visualization.web_server.flatbuffers.Text.addFontFamily = function (
+  builder,
+  fontFamilyOffset
+) {
+  builder.addFieldOffset(4, fontFamilyOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} fontSize
+ */
+casymda.visualization.web_server.flatbuffers.Text.addFontSize = function (
+  builder,
+  fontSize
+) {
+  builder.addFieldInt8(5, fontSize, 10);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Text.endText = function (builder) {
+  var offset = builder.endObject();
+  return offset;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} positionOffset
+ * @param {flatbuffers.Offset} anchorOffset
+ * @param {flatbuffers.Offset} textOffset
+ * @param {flatbuffers.Offset} fillOffset
+ * @param {flatbuffers.Offset} fontFamilyOffset
+ * @param {number} fontSize
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Text.createText = function (
+  builder,
+  positionOffset,
+  anchorOffset,
+  textOffset,
+  fillOffset,
+  fontFamilyOffset,
+  fontSize
+) {
+  casymda.visualization.web_server.flatbuffers.Text.startText(builder);
+  casymda.visualization.web_server.flatbuffers.Text.addPosition(
+    builder,
+    positionOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Text.addAnchor(
+    builder,
+    anchorOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Text.addText(
+    builder,
+    textOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Text.addFill(
+    builder,
+    fillOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Text.addFontFamily(
+    builder,
+    fontFamilyOffset
+  );
+  casymda.visualization.web_server.flatbuffers.Text.addFontSize(
+    builder,
+    fontSize
+  );
+  return casymda.visualization.web_server.flatbuffers.Text.endText(builder);
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.CanvasPosition = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.CanvasPosition}
+ */
+casymda.visualization.web_server.flatbuffers.CanvasPosition.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.CanvasPosition.prototype.x = function () {
+  return this.bb.readUint16(this.bb_pos);
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.CanvasPosition.prototype.y = function () {
+  return this.bb.readUint16(this.bb_pos + 2);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} x
+ * @param {number} y
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.CanvasPosition.createCanvasPosition = function (
+  builder,
+  x,
+  y
+) {
+  builder.prep(2, 4);
+  builder.writeInt16(y);
+  builder.writeInt16(x);
+  return builder.offset();
+};
+
+/**
+ * @constructor
+ */
+casymda.visualization.web_server.flatbuffers.Anchor = function () {
+  /**
+   * @type {flatbuffers.ByteBuffer}
+   */
+  this.bb = null;
+
+  /**
+   * @type {number}
+   */
+  this.bb_pos = 0;
+};
+
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {casymda.visualization.web_server.flatbuffers.Anchor}
+ */
+casymda.visualization.web_server.flatbuffers.Anchor.prototype.__init = function (
+  i,
+  bb
+) {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Anchor.prototype.x = function () {
+  return this.bb.readFloat32(this.bb_pos);
+};
+
+/**
+ * @returns {number}
+ */
+casymda.visualization.web_server.flatbuffers.Anchor.prototype.y = function () {
+  return this.bb.readFloat32(this.bb_pos + 4);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} x
+ * @param {number} y
+ * @returns {flatbuffers.Offset}
+ */
+casymda.visualization.web_server.flatbuffers.Anchor.createAnchor = function (
+  builder,
+  x,
+  y
+) {
+  builder.prep(4, 8);
+  builder.writeFloat32(y);
+  builder.writeFloat32(x);
+  return builder.offset();
+};
+
+// Exports for Node.js and RequireJS
+export { casymda };

src/casymda/visual...n/web_server/flatbuffer_deserializer.js

+import { casymda } from "./csa_generated.js";
+console.log("flattbuffer deserializer loaded");
+
+export async function deserialize_fb(response) {
+  const array = await response.arrayBuffer(); // blob?
+  const data = new Uint8Array(array);
+  const buffer = new flatbuffers.ByteBuffer(data);
+  const canvas = casymda.visualization.web_server.flatbuffers.Canvas.getRootAsCanvas(
+    buffer
+  );
+
+  const state = {};
+
+  const num_elements = canvas.contentLength();
+  for (let i = 0; i < num_elements; i++) {
+    const fb_element = canvas.content(i);
+    const fb_typ = fb_element.elementType();
+    const id_num = fb_element.id();
+
+    const element = {};
+    if (
+      fb_typ == casymda.visualization.web_server.flatbuffers.ElementsUnion.Photo
+    ) {
+      const fb_photo = new casymda.visualization.web_server.flatbuffers.Photo();
+      fb_photo.__init(fb_element.element(fb_element).bb_pos, buffer);
+      element.type = "photo";
+      element.path = fb_photo.path();
+      element.factor = fb_photo.factor();
+    } else if (
+      fb_typ == casymda.visualization.web_server.flatbuffers.ElementsUnion.Image
+    ) {
+      // image
+      const fb_image = new casymda.visualization.web_server.flatbuffers.Image();
+      fb_image.__init(fb_element.element(fb_element).bb_pos, buffer);
+      element.type = "image";
+      element.x = fb_image.position().x();
+      element.y = fb_image.position().y();
+      element.anchor = [fb_image.anchor().x(), fb_image.anchor().y()];
+      element.photo_id = fb_image.photoId();
+      element.path = fb_image.path();
+      element.factor = fb_image.factor();
+    } else if (
+      fb_typ == casymda.visualization.web_server.flatbuffers.ElementsUnion.Text
+    ) {
+      // text
+      const fb_text = new casymda.visualization.web_server.flatbuffers.Text();
+      fb_text.__init(fb_element.element(fb_element).bb_pos, buffer);
+      element.type = "text";
+      element.x = fb_text.position().x();
+      element.y = fb_text.position().y();
+      element.anchor = [fb_text.anchor().x(), fb_text.anchor().y()];
+      element.text = fb_text.text();
+      element.fill = fb_text.fill();
+      element.font_family = fb_text.fontFamily();
+      element.font_size = fb_text.fontSize();
+    }
+    state[id_num.toString()] = element; // move to end
+  }
+  return state;
+}

src/casymda/visualization/web_server/flatbuffers/__init__.py

src/casymda/visualization/web_server/flatbuffers/Anchor.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Anchor(object):
+    __slots__ = ['_tab']
+
+    # Anchor
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Anchor
+    def X(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # Anchor
+    def Y(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
+
+def CreateAnchor(builder, x, y):
+    builder.Prep(4, 8)
+    builder.PrependFloat32(y)
+    builder.PrependFloat32(x)
+    return builder.Offset()

src/casymda/visualization/web_server/flatbuffers/Canvas.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Canvas(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsCanvas(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Canvas()
+        x.Init(buf, n + offset)
+        return x
+
+    # Canvas
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Canvas
+    def Content(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from casymda.visualization.web_server.flatbuffers.Element import Element
+            obj = Element()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Canvas
+    def ContentLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Canvas
+    def ContentIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def CanvasStart(builder): builder.StartObject(1)
+def CanvasAddContent(builder, content): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(content), 0)
+def CanvasStartContentVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def CanvasEnd(builder): return builder.EndObject()

src/casymda/visual...eb_server/flatbuffers/CanvasPosition.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CanvasPosition(object):
+    __slots__ = ['_tab']
+
+    # CanvasPosition
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CanvasPosition
+    def X(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # CanvasPosition
+    def Y(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2))
+
+def CreateCanvasPosition(builder, x, y):
+    builder.Prep(2, 4)
+    builder.PrependUint16(y)
+    builder.PrependUint16(x)
+    return builder.Offset()

src/casymda/visualization/web_server/flatbuffers/Element.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Element(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsElement(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Element()
+        x.Init(buf, n + offset)
+        return x
+
+    # Element
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Element
+    def Id(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Element
+    def ElementType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Element
+    def Element(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+def ElementStart(builder): builder.StartObject(3)
+def ElementAddId(builder, id): builder.PrependUint16Slot(0, id, 0)
+def ElementAddElementType(builder, elementType): builder.PrependUint8Slot(1, elementType, 0)
+def ElementAddElement(builder, element): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(element), 0)
+def ElementEnd(builder): return builder.EndObject()

src/casymda/visual...web_server/flatbuffers/ElementsUnion.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+class ElementsUnion(object):
+    NONE = 0
+    Photo = 1
+    Image = 2
+    Text = 3
+

src/casymda/visual...er/flatbuffers/flatbuffer_serializer.py

+import flatbuffers
+
+from . import Anchor, Canvas, CanvasPosition, Element, Image, Photo, Text
+from .ElementsUnion import ElementsUnion
+
+
+def serialize(state: dict):
+
+    num_elements = len(state)
+    fb = flatbuffers.Builder(1024)  # default decisive?
+
+    elements = []
+    i: str
+    e: dict
+    for i, e in state.items():
+
+        if e["type"] == "photo":
+            path = fb.CreateString(e["path"])
+            Photo.PhotoStart(fb)
+            Photo.PhotoAddFactor(fb, e["factor"])
+            Photo.PhotoAddPath(fb, path)
+            elementBody = Photo.PhotoEnd(fb)
+            elementType = ElementsUnion.Photo
+
+        elif e["type"] == "image":
+            path = fb.CreateString(e["path"])
+            Image.ImageStart(fb)
+            Image.ImageAddAnchor(fb, Anchor.CreateAnchor(fb, *e["anchor"]))
+            Image.ImageAddFactor(fb, e["factor"])
+            Image.ImageAddPath(fb, path)
+            Image.ImageAddPhotoId(fb, e["photo_id"])
+            Image.ImageAddPosition(
+                fb, CanvasPosition.CreateCanvasPosition(fb, e["x"], e["y"])
+            )
+            elementBody = Image.ImageEnd(fb)
+            elementType = ElementsUnion.Image
+
+        elif e["type"] == "text":
+            fill = fb.CreateString(e["fill"])
+            font = fb.CreateString(e["font_family"])
+            text = fb.CreateString(e["text"])
+            Text.TextStart(fb)
+            Text.TextAddAnchor(fb, Anchor.CreateAnchor(fb, *e["anchor"]))
+            Text.TextAddFill(fb, fill)
+            Text.TextAddFontFamily(fb, font)
+            Text.TextAddFontSize(fb, e["font_size"])
+            Text.TextAddPosition(
+                fb, CanvasPosition.CreateCanvasPosition(fb, e["x"], e["y"])
+            )
+            Text.TextAddText(fb, text)
+            elementBody = Text.TextEnd(fb)
+            elementType = ElementsUnion.Text
+
+        Element.ElementStart(fb)
+        Element.ElementAddId(fb, int(i))
+        Element.ElementAddElementType(fb, elementType)
+        Element.ElementAddElement(fb, elementBody)
+        element = Element.ElementEnd(fb)
+        elements.append(element)
+
+    Canvas.CanvasStartContentVector(fb, num_elements)
+    for elem in elements:
+        fb.PrependUOffsetTRelative(elem)
+    content = fb.EndVector(num_elements)
+
+    Canvas.CanvasStart(fb)
+    Canvas.CanvasAddContent(fb, content)
+    canvas = Canvas.CanvasEnd(fb)
+
+    fb.Finish(canvas)
+    binary = fb.Output()
+
+    return binary

src/casymda/visualization/web_server/flatbuffers/Image.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Image(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsImage(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Image()
+        x.Init(buf, n + offset)
+        return x
+
+    # Image
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Image
+    def Position(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = o + self._tab.Pos
+            from casymda.visualization.web_server.flatbuffers.CanvasPosition import CanvasPosition
+            obj = CanvasPosition()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Image
+    def Anchor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = o + self._tab.Pos
+            from casymda.visualization.web_server.flatbuffers.Anchor import Anchor
+            obj = Anchor()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Image
+    def PhotoId(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Image
+    def Path(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Image
+    def Factor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+def ImageStart(builder): builder.StartObject(5)
+def ImageAddPosition(builder, position): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(position), 0)
+def ImageAddAnchor(builder, anchor): builder.PrependStructSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(anchor), 0)
+def ImageAddPhotoId(builder, photoId): builder.PrependUint16Slot(2, photoId, 0)
+def ImageAddPath(builder, path): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(path), 0)
+def ImageAddFactor(builder, factor): builder.PrependFloat32Slot(4, factor, 1.0)
+def ImageEnd(builder): return builder.EndObject()

src/casymda/visualization/web_server/flatbuffers/Photo.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Photo(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsPhoto(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Photo()
+        x.Init(buf, n + offset)
+        return x
+
+    # Photo
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Photo
+    def Factor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # Photo
+    def Path(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def PhotoStart(builder): builder.StartObject(2)
+def PhotoAddFactor(builder, factor): builder.PrependFloat32Slot(0, factor, 1.0)
+def PhotoAddPath(builder, path): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(path), 0)
+def PhotoEnd(builder): return builder.EndObject()

src/casymda/visualization/web_server/flatbuffers/Text.py

+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: flatbuffers
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Text(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsText(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Text()
+        x.Init(buf, n + offset)
+        return x
+
+    # Text
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Text
+    def Position(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = o + self._tab.Pos
+            from casymda.visualization.web_server.flatbuffers.CanvasPosition import CanvasPosition
+            obj = CanvasPosition()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Text
+    def Anchor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = o + self._tab.Pos
+            from casymda.visualization.web_server.flatbuffers.Anchor import Anchor
+            obj = Anchor()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Text
+    def Text(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Text
+    def Fill(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Text
+    def FontFamily(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Text
+    def FontSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 10
+
+def TextStart(builder): builder.StartObject(6)
+def TextAddPosition(builder, position): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(position), 0)
+def TextAddAnchor(builder, anchor): builder.PrependStructSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(anchor), 0)
+def TextAddText(builder, text): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(text), 0)
+def TextAddFill(builder, fill): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fill), 0)
+def TextAddFontFamily(builder, fontFamily): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fontFamily), 0)
+def TextAddFontSize(builder, fontSize): builder.PrependUint8Slot(5, fontSize, 10)
+def TextEnd(builder): return builder.EndObject()

PKG-INFO

 Metadata-Version: 2.1
 Name: casymda
-Version: 0.2.25
-Summary: A simple DES modeling and simulation environment based on simpy, camunda modeler, and tkinter / pixi.js;
+Version: 0.2.26
+Summary: Simple DES modeling and simulation based on SimPy, BPMN, and pixi.js
 Home-page: https://github.com/fladdimir/casymda
@@ -6,0 +6,0 @@ Author: FFC

setup.py

@@ -5,3 +5,3 @@ """setuptools setup"""
 
-VERSION = "0.2.25"
+VERSION = "0.2.26"
 
@@ -39,4 +39,4 @@ try:
     license="MIT",
-    description="A simple DES modeling and simulation environment"
-    + " based on simpy, camunda modeler, and tkinter / pixi.js;",
+    description="Simple DES modeling and simulation"
+    + " based on SimPy, BPMN, and pixi.js",
     classifiers=[
@@ -43,0 +43,0 @@ "Development Status :: 3 - Alpha",

src/casymda.egg-info/PKG-INFO

 Metadata-Version: 2.1
 Name: casymda
-Version: 0.2.25
-Summary: A simple DES modeling and simulation environment based on simpy, camunda modeler, and tkinter / pixi.js;
+Version: 0.2.26
+Summary: Simple DES modeling and simulation based on SimPy, BPMN, and pixi.js
 Home-page: https://github.com/fladdimir/casymda
@@ -6,0 +6,0 @@ Author: FFC

src/casymda.egg-info/requires.txt

@@ -0,8 +1,8 @@
+simpy
+xmltodict
 Pillow
-black==19.3b0
 flask
 flask-cors
+black==19.3b0
+numpy
 networkx
-numpy
-simpy
-xmltodict

src/casymda.egg-info/SOURCES.txt

@@ -53,4 +53,16 @@ MANIFEST.in
 src/casymda/visualization/web_server/canvas_animation.html
+src/casymda/visualization/web_server/csa_generated.js
 src/casymda/visualization/web_server/flask_sim_server.py
+src/casymda/visualization/web_server/flatbuffer_deserializer.js
 src/casymda/visualization/web_server/pixijs_canvas_animation.js
-src/casymda/visualization/web_server/sim_controller.py
+src/casymda/visualization/web_server/sim_controller.py
+src/casymda/visualization/web_server/flatbuffers/Anchor.py
+src/casymda/visualization/web_server/flatbuffers/Canvas.py
+src/casymda/visualization/web_server/flatbuffers/CanvasPosition.py
+src/casymda/visualization/web_server/flatbuffers/Element.py
+src/casymda/visualization/web_server/flatbuffers/ElementsUnion.py
+src/casymda/visualization/web_server/flatbuffers/Image.py
+src/casymda/visualization/web_server/flatbuffers/Photo.py
+src/casymda/visualization/web_server/flatbuffers/Text.py
+src/casymda/visualization/web_server/flatbuffers/__init__.py
+src/casymda/visualization/web_server/flatbuffers/flatbuffer_serializer.py

src/casymda/__init__.py

@@ -1,1 +0,1 @@
-__version__ = "0.2.25"
+__version__ = "0.2.26"

src/casymda/blocks/delay.py

@@ -12,4 +12,12 @@ """ process """
 
-    def __init__(self, env, name, xy=None, ways=None, process_time=1.0):
-        super().__init__(env, name, xy=xy, ways=ways)
+    def __init__(
+        self,
+        env,
+        name,
+        xy=None,
+        ways=None,
+        process_time=1.0,
+        block_capacity=float("inf"),
+    ):
+        super().__init__(env, name, xy=xy, ways=ways, block_capacity=block_capacity)
         self.process_time = process_time
@@ -16,0 +24,0 @@

src/casymda/blocks/tilemap/tilemap_nx.py

 """calculates and caches information on shortest paths between locations on a tilemap"""
+import math
+import multiprocessing
+import os
 import pickle
-from typing import Dict, Any, Tuple
+import time
+from typing import Any, Dict, Tuple
 
 import networkx as nx
+from networkx.classes.function import path_weight
 from numpy import genfromtxt, vectorize
@@ -126,3 +131,10 @@
     node_lookup_by_name = {value["name"]: key for key, value in nodes.items()}
+
+    print("starting to calculate tilemap paths - this may take a while..")
+    start_time = time.time()
     matrix_dict = calculate_matrix_dict(graph, nodes_list)
+    print(
+        "time needed for shortest paths calculation [s]: "
+        + str(time.time() - start_time)
+    )
     return matrix_dict, node_lookup_by_name
@@ -136,3 +148,3 @@
     for element in _get_elements_in_array(array):
-        if len(array[element]) is not 0 and array[element] not in ["0", "1"]:
+        if len(array[element]) != 0 and array[element] not in ["0", "1"]:
             relevant_nodes[element] = {"name": array[element]}
@@ -142,4 +154,64 @@ return relevant_nodes
 
+def euclidean_distance(a, b):
+    return math.sqrt((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2)
+
+
 def calculate_matrix_dict(graph, nodes):
     # {from: {to1: {path:[...], length: X}, to2: ...}}
+    pairs = {}  # all simple paths to calculate
+    for source_node in nodes:
+        for target_node in filter(lambda n: n is not source_node, nodes):
+            if target_node in pairs and source_node in pairs[target_node]:
+                continue
+            if source_node not in pairs:
+                pairs[source_node] = {}
+            pairs[source_node][target_node] = None
+
+    pairs_list_with_graph = []  # prepare data to be processed concurrently
+    for source_node in pairs:
+        for target_node in pairs[source_node]:
+            pairs_list_with_graph.append((source_node, target_node, graph))
+
+    mp_pool = multiprocessing.Pool(os.cpu_count())  # default
+    print("multiprocessing pool size: " + str(os.cpu_count()))
+    results_list = mp_pool.map(
+        calculate_path_and_length_both_directions_from_tuple,
+        pairs_list_with_graph,
+    )
+
+    result = {  # initialize dict
+        source_node: {
+            target_node: None for target_node in nodes if source_node is not target_node
+        }
+        for source_node in nodes
+    }
+    for entry in results_list:  # fill with results
+        for source_node in entry:
+            for target_node in entry[source_node]:
+                result[source_node][target_node] = entry[source_node][target_node]
+    return result
+
+
+def calculate_path_and_length_both_directions_from_tuple(t):
+    return calculate_path_and_length_both_directions(*t)  # node_1, node_2, graph
+
+
+def calculate_path_and_length_both_directions(node_1, node_2, graph):
+    path = nx.astar_path(
+        graph,
+        node_1,
+        node_2,
+        heuristic=euclidean_distance,
+        weight="weight",
+    )
+    length = path_weight(graph, path, "weight")
+    result = {
+        node_1: {node_2: {"path": path, "length": length}},
+        node_2: {node_1: {"path": list(reversed(path)), "length": length}},
+    }
+    return result
+
+
+def calculate_matrix_dict_alt(graph, nodes):
+    # {from: {to1: {path:[...], length: X}, to2: ...}}
     result = {}
@@ -146,0 +218,0 @@ for source_node in nodes:

src/casymda/visualization/canvas/web_canvas.py

@@ -15,3 +15,5 @@ from casymda.visualization.canvas.scaled_canvas import ScaledCanvas
 
+UPDATED_KEY = "__UPDATED__"
 
+
 class WebCanvas(ScaledCanvas):
@@ -34,2 +36,4 @@ """
 
+        self.dict[UPDATED_KEY] = set()  # set of all updated element_ids
+
     def load_image_file(self, path):
@@ -45,2 +49,3 @@ potential_key = path
         }
+        self.update_updated(self.element_id_counter)
         self.photo_lookup[potential_key] = self.element_id_counter
@@ -61,2 +66,3 @@ return self.element_id_counter
         }
+        self.update_updated(self.element_id_counter)
         return self.element_id_counter
@@ -79,2 +85,3 @@
         }
+        self.update_updated(self.element_id_counter)
         return self.element_id_counter
@@ -95,2 +102,3 @@
             self.dict[element_id] = entry
+            self.update_updated(element_id)
             return True
@@ -104,2 +112,3 @@ return False
             self.dict[element_id] = entry
+            self.update_updated(element_id)
             return True
@@ -113,1 +122,6 @@ return False
         return self.height
+
+    def update_updated(self, id: int):
+        updated_set = set(self.dict[UPDATED_KEY])
+        updated_set.add(id)
+        self.dict[UPDATED_KEY] = updated_set  # trigger process synchro

src/casymda/visualization/web_server/animation_client.js

@@ -1,4 +0,9 @@
-console.log("animation_client.js loaded");
+import {
+  initialize_animation,
+  animate_simulation,
+} from "./pixijs_canvas_animation.js";
+import { deserialize_fb } from "./flatbuffer_deserializer.js";
 
 // constants
+const BINARY_TRANSFER = true;
 const BASE_URL = window.location.origin;
@@ -9,3 +14,5 @@ const START_URL = BASE_URL + "/start";
 const STOP_URL = BASE_URL + "/stop";
-const STATE_URL = BASE_URL + "/state";
+const STATE_URL = BASE_URL + "/state" + (BINARY_TRANSFER ? "_fb" : "");
+const PARTIAL_STATE_URL =
+  BASE_URL + "/partial_state" + (BINARY_TRANSFER ? "_fb" : "");
 const RT_FACTOR_BASE_URL = BASE_URL + "/rt_factor?value=";
@@ -16,6 +23,4 @@
 
-
 const ANIMATION_CANVAS_PARENT_ID = "animation_canvas_parent";
 let ANIMATION_CANVAS_PARENT;
-document.addEventListener('DOMContentLoaded', () => { ANIMATION_CANVAS_PARENT = document.querySelector("#" + ANIMATION_CANVAS_PARENT_ID); });
 
@@ -25,9 +30,16 @@ const running_timeouts = [];
 let state = {};
+let time_of_last_full_update = 0;
+const TIME_BETWEEN_FULL_UPDATES_MS = 500;
 
+const LOG_PERFORMANCE = true;
+let num_requests = 0;
+let num_animation_updates = 0;
+let animation_update_times = [];
+const LOG_INTERVAL_SEC = 2;
 
 // HTTP HELPER
 function post(url) {
-    const request = new XMLHttpRequest();
-    request.open("POST", url);
-    request.send();
+  const request = new XMLHttpRequest();
+  request.open("POST", url);
+  request.send();
 }
@@ -37,72 +49,160 @@
 async function start_simulation() {
-    stop_simulation();
+  stop_simulation();
 
-    // retrieve canvas dimensions first
-    const canvas_width = await get_canvas_width();
-    const canvas_height = await get_canvas_height();
+  // retrieve canvas dimensions first
+  const canvas_width = await get_canvas_width();
+  const canvas_height = await get_canvas_height();
 
-    post(START_URL);
-    initialize_animation(ANIMATION_CANVAS_PARENT, canvas_width, canvas_height);
+  post(START_URL);
+  initialize_animation(ANIMATION_CANVAS_PARENT, canvas_width, canvas_height);
 
-    state = {};
+  state = {};
 
-    stopped = false;
-    request_state_loop();
+  stopped = false;
+  setup_request_state_loop();
+  setup_animation_loop();
+  if (LOG_PERFORMANCE) log_performance_loop();
 }
 
-function request_state_loop() {
-    if (!stopped) running_timeouts.push(setTimeout(state_query, 20, [request_state_loop, animate_current_state]));
+function log_performance_loop() {
+  let interval = window.setInterval(() => {
+    console.log("Reqests/sec: " + num_requests / LOG_INTERVAL_SEC);
+    console.log("Updates/sec: " + num_animation_updates / LOG_INTERVAL_SEC);
+    console.log(
+      "Average animation update time (ms): " +
+        animation_update_times.reduce((a, b) => a + b, 0) /
+          animation_update_times.length
+    );
+    num_requests = 0;
+    num_animation_updates = 0;
+    animation_update_times = [];
+  }, LOG_INTERVAL_SEC * 1000);
+  running_timeouts.push(interval);
 }
 
-async function state_query(callbacks) {
-    const response = await fetch(STATE_URL);
-    state = await response.json();
-    callbacks.forEach(callback => {
-        callback();
-    });
+function setup_request_state_loop() {
+  let interval = window.setInterval(state_query, 35);
+  running_timeouts.push(interval);
 }
 
+async function state_query() {
+  if (Date.now() - time_of_last_full_update > TIME_BETWEEN_FULL_UPDATES_MS) {
+    // full update
+    time_of_last_full_update = Date.now();
+    await full_state_update();
+  } else {
+    // partial update
+    await partial_state_update();
+  }
+  num_requests++;
+}
+
+async function full_state_update() {
+  const response = await fetch_state();
+  state = await deserialize(response);
+}
+
+async function partial_state_update() {
+  const partial_response = await fetch_partial_state();
+  const partial_state = await deserialize(partial_response);
+  state = partial_update(state, partial_state);
+}
+
+async function fetch_partial_state() {
+  return fetch(PARTIAL_STATE_URL);
+}
+
+async function fetch_state() {
+  return fetch(STATE_URL);
+}
+
+async function deserialize(response) {
+  return BINARY_TRANSFER ? deserialize_binary(response) : response.json();
+}
+
+async function deserialize_binary(response) {
+  return deserialize_fb(response);
+}
+
+function partial_update(state, partial_state) {
+  return Object.assign(state, partial_state);
+}
+
+function setup_animation_loop() {
+  const minTime = 35;
+  let time = Date.now();
+  animate_current_state(); // could be further improved by info on actually updated partial state
+  time = Date.now() - time;
+  if (LOG_PERFORMANCE) animation_update_times.push(time);
+  let timeout = Math.max(minTime - time, 0);
+  let interval = window.setTimeout(setup_animation_loop, timeout);
+  running_timeouts.push(interval);
+}
+
 function animate_current_state() {
-    animate_simulation(state);
+  animate_simulation(state);
+  num_animation_updates++;
 }
 
-
 function pause_simulation() {
-    post(PAUSE_URL);
+  post(PAUSE_URL);
 }
 
 function resume_simulation() {
-    post(RESUME_URL);
+  post(RESUME_URL);
 }
 
 function stop_simulation() {
-    stopped = true;
-    post(STOP_URL);
-    while (running_timeouts.length > 0) {
-        clearTimeout(running_timeouts.pop());
-    }
+  stopped = true;
+  post(STOP_URL);
+  while (running_timeouts.length > 0) {
+    clearTimeout(running_timeouts.pop());
+  }
 }
 
 function speed_slider_changed_to(value) {
-    value = 101 - value;  // 1 - 100
-    value /= 100;  // 0.01 - 1
-    value = Math.pow(value, 3);  // exponential speedup
-    set_rt_factor(value);
-    return value;
+  value = 101 - value; // 1 - 100
+  value /= 100; // 0.01 - 1
+  value = Math.pow(value, 3); // exponential speedup
+  set_rt_factor(value);
+  return value;
 }
 
 function set_rt_factor(value) {
-    post(RT_FACTOR_BASE_URL + String(value));
+  post(RT_FACTOR_BASE_URL + String(value));
 }
 
 async function get_canvas_height() {
-    const response = await fetch(CANVAS_HEIGHT_URL);
-    const content = await response.text();
-    return Number(content);
+  const response = await fetch(CANVAS_HEIGHT_URL);
+  const content = await response.text();
+  return Number(content);
 }
 
 async function get_canvas_width() {
-    const response = await fetch(CANVAS_WIDTH_URL);
-    const content = await response.text();
-    return Number(content);
+  const response = await fetch(CANVAS_WIDTH_URL);
+  const content = await response.text();
+  return Number(content);
 }
+
+// document interaction
+document.addEventListener("DOMContentLoaded", () => {
+  ANIMATION_CANVAS_PARENT = document.querySelector(
+    "#" + ANIMATION_CANVAS_PARENT_ID
+  );
+  var speed_slider = document.getElementById("speed_slider");
+  var speed_label = document.getElementById("speed_label");
+  function change_factor(value) {
+    speed_label.innerHTML = (1 / speed_slider_changed_to(value)).toFixed(2);
+  }
+  change_factor(speed_slider.value);
+  speed_slider.oninput = function () {
+    change_factor(this.value);
+  };
+});
+
+window.start_simulation = start_simulation;
+window.pause_simulation = pause_simulation;
+window.resume_simulation = resume_simulation;
+window.stop_simulation = stop_simulation;
+
+console.log("animation_client.js loaded");

src/casymda/visualization/web_server/canvas_animation.html

@@ -9,9 +9,10 @@ <!DOCTYPE html>
     <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
-    <script src="https://pixijs.download/v5.0.4/pixi.min.js">// TODO: provide locally to run offline</script>
+    <script src="https://pixijs.download/v5.0.4/pixi.min.js"></script>
 
     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap-theme.min.css">
-
-    <script src="lib-files/animation_client.js"></script>
-    <script src="lib-files/pixijs_canvas_animation.js"></script>
+    
+    <script src="https://unpkg.com/flatbuffers@1.12.0/js/flatbuffers.js"></script>
+    
+    <script type="module" src="lib-files/animation_client.js"></script>
 </head>
@@ -32,13 +33,2 @@
                 <p>real-time factor: <span id="speed_label"></span></p>
-                <script>
-                    var speed_slider = document.getElementById("speed_slider");
-                    var speed_label = document.getElementById("speed_label");
-                    function change_factor(value) {
-                        speed_label.innerHTML = (1 / speed_slider_changed_to(value)).toFixed(2);
-                    }
-                    change_factor(speed_slider.value);
-                    speed_slider.oninput = function () {
-                        change_factor(this.value);
-                    }
-                </script>
             </div>
@@ -45,0 +35,0 @@ <hr>

src/casymda/visualization/web_server/flask_sim_server.py

@@ -8,3 +8,3 @@ import logging
 )
-from flask import Flask, request, send_file, send_from_directory
+from flask import Flask, request, send_file, send_from_directory, Response
 from flask_cors import CORS
@@ -32,3 +32,4 @@
         print(
-            "starting flask server, app_dir: %s, flask_dir: %s" % (app_dir, flask_dir)
+            "starting flask server, port: %s, app_dir: %s, flask_dir: %s"
+            % (self.port, app_dir, flask_dir)
         )
@@ -69,2 +70,16 @@
 
+        @app.route("/partial_state")
+        def get_partial_state():
+            return self.sim_controller.get_partial_state_dumps()
+
+        @app.route("/state_fb")  # flatbuffers binary
+        def get_state_fb():
+            binary = self.sim_controller.get_state_dumps_fb()
+            return Response(binary, mimetype="binary/octet-stream")
+
+        @app.route("/partial_state_fb")  # flatbuffers binary
+        def get_partial_state_fb():
+            binary = self.sim_controller.get_partial_state_dumps_fb()
+            return Response(binary, mimetype="binary/octet-stream")
+
         @app.route("/start", methods=["POST"])
@@ -91,2 +106,3 @@ def start():
 
+        # set debug=False for IDE debugging
         app.run(debug=True, threaded=False, port=self.port, host=self.host)
@@ -93,0 +109,0 @@

src/casymda/visual...n/web_server/pixijs_canvas_animation.js

@@ -1,9 +0,6 @@
-console.log("pixijs_canvas_animation.js loaded")
-// pixijs-based animation
-
-let type = "WebGL"
+let type = "WebGL";
 if (!PIXI.utils.isWebGLSupported()) {
-    type = "canvas"
+  type = "canvas";
 }
-PIXI.utils.sayHello(type)
+PIXI.utils.sayHello(type);
 
@@ -14,31 +11,31 @@ let app, loader;
 // create pixi canvas at certain element
-function initialize_animation(parent_dom_element, width, height) {
+export function initialize_animation(parent_dom_element, width, height) {
+  remove_old_canvas_elements(parent_dom_element);
+  app = new PIXI.Application({
+    width: width,
+    height: height,
+    backgroundColor: 0xffffff,
+  });
+  app.ticker.maxFPS = 30;
+  app.stage.sortableChildren = true;
+  parent_dom_element.appendChild(app.view);
 
-    remove_old_canvas_elements(parent_dom_element);
-    app = new PIXI.Application({
-        width: width, height: height,
-        backgroundColor: 0xFFFFFF
-    });
-    app.ticker.maxFPS = 30;
-    app.stage.sortableChildren = true;
-    parent_dom_element.appendChild(app.view);
+  loader = new PIXI.Loader();
 
-    loader = new PIXI.Loader();
-
-    animated_elements = {};
+  animated_elements = {};
 }
 
 // process given state
-function animate_simulation(state) {
+export function animate_simulation(state) {
+  // process all elements
+  for (var key in state) {
+    var state_element = state[key];
+    if (state_element.type === "text") _process_text(key, state_element);
+    else if (state_element.type === "photo") _process_resource(state_element);
+    // "photo" means image resource (to be loaded)
+    else if (state_element.type === "image") _process_image(key, state_element);
+  }
 
-    // process all elements
-    for (var key in state) {
-        var state_element = state[key];
-        if (state_element.type === "text") _process_text(key, state_element);
-        else if (state_element.type === "photo") _process_resource(state_element); // "photo" means image resource (to be loaded)
-        else if (state_element.type === "image") _process_image(key, state_element);
-    }
-
-    // also check if some animated elements are not present anymore
-    destroy_removed_elements(state);
+  // also check if some animated elements are not present anymore
+  destroy_removed_elements(state);
 }
@@ -48,59 +45,75 @@
 function _process_resource(state_element) {
-    // check if the resource is already loaded and start to load it if not
-    if (!(state_element.path in loader.resources) && !loader.loading) {
-        let element_to_load = loader.add(state_element.path, "files?filepath=" + state_element.path);
-        element_to_load.load();
-    }
+  // check if the resource is already loaded and start to load it if not
+  if (!(state_element.path in loader.resources) && !loader.loading) {
+    let element_to_load = loader.add(
+      state_element.path,
+      "files?filepath=" + state_element.path
+    );
+    element_to_load.load();
+  }
 }
 
 function _process_image(key, state_element) {
-    var pixi_sprite;
-    if (!(key in animated_elements) && state_element.path in loader.resources && loader.resources[state_element.path].isComplete) {
-        // create new sprite
-        pixi_sprite = new PIXI.Sprite.from("files?filepath=" + state_element.path);
-        pixi_sprite.scale.set((state_element.factor, state_element.factor))
-        pixi_sprite.anchor.set(state_element.anchor[0], state_element.anchor[1]);
-        pixi_sprite.zIndex = parseInt(key);
-        app.stage.addChild(pixi_sprite);
-        animated_elements[key] = pixi_sprite;
-    }
-    if (key in animated_elements) {
-        // update properties
-        pixi_sprite = animated_elements[key];
-        pixi_sprite.position.x = state_element.x;
-        pixi_sprite.position.y = state_element.y;
-    }
+  var pixi_sprite;
+  if (
+    !(key in animated_elements) &&
+    state_element.path in loader.resources &&
+    loader.resources[state_element.path].isComplete
+  ) {
+    // create new sprite
+    pixi_sprite = new PIXI.Sprite.from("files?filepath=" + state_element.path);
+    pixi_sprite.scale.set((state_element.factor, state_element.factor));
+    pixi_sprite.anchor.set(state_element.anchor[0], state_element.anchor[1]);
+    pixi_sprite.zIndex = parseInt(key);
+    app.stage.addChild(pixi_sprite);
+    animated_elements[key] = pixi_sprite;
+  }
+  if (key in animated_elements) {
+    // update properties
+    pixi_sprite = animated_elements[key];
+    pixi_sprite.position.x = state_element.x;
+    pixi_sprite.position.y = state_element.y;
+  }
 }
 
 function _process_text(key, state_element) {
-    var pixi_text;
-    if (animated_elements[key] === undefined) {
-        // create text on canvas
-        pixi_text = new PIXI.Text("", { fontFamily: state_element.font_family, fontSize: state_element.font_size, fill: state_element.fill });
-        pixi_text.anchor.set(state_element.anchor[0], state_element.anchor[1]);
-        pixi_text.zIndex = parseInt(key);
-        app.stage.addChild(pixi_text);
-        animated_elements[key] = pixi_text;
-    }
-    // update properties: position / text
-    pixi_text = animated_elements[key];
-    pixi_text.position.x = state_element.x;
-    pixi_text.position.y = state_element.y;
-    pixi_text.text = state_element.text;
+  var pixi_text;
+  if (animated_elements[key] === undefined) {
+    // create text on canvas
+    pixi_text = new PIXI.Text("", {
+      fontFamily: state_element.font_family,
+      fontSize: state_element.font_size,
+      fill: state_element.fill,
+    });
+    pixi_text.anchor.set(state_element.anchor[0], state_element.anchor[1]);
+    pixi_text.zIndex = parseInt(key);
+    app.stage.addChild(pixi_text);
+    animated_elements[key] = pixi_text;
+  }
+  // update properties: position / text
+  pixi_text = animated_elements[key];
+  pixi_text.position.x = state_element.x;
+  pixi_text.position.y = state_element.y;
+  pixi_text.text = state_element.text;
 }
 
-
 function remove_old_canvas_elements(parent_dom_element) {
-    while (parent_dom_element && parent_dom_element.lastChild && parent_dom_element.lastChild.nodeName == "CANVAS") {
-        parent_dom_element.removeChild(parent_dom_element.lastChild);
-    }
+  while (
+    parent_dom_element &&
+    parent_dom_element.lastChild &&
+    parent_dom_element.lastChild.nodeName == "CANVAS"
+  ) {
+    parent_dom_element.removeChild(parent_dom_element.lastChild);
+  }
 }
 
 function destroy_removed_elements(state) {
-    for (var anim_key in animated_elements) {
-        if (!(anim_key in state)) {
-            animated_elements[anim_key].destroy();
-            delete animated_elements[anim_key];
-        }
+  for (var anim_key in animated_elements) {
+    if (!(anim_key in state)) {
+      animated_elements[anim_key].destroy();
+      delete animated_elements[anim_key];
     }
+  }
 }
+
+console.log("pixijs_canvas_animation.js loaded");

src/casymda/visualization/web_server/sim_controller.py

@@ -9,6 +9,9 @@ """runs simulation model in its own process"""
 from casymda.environments.realtime_environment import SyncedFloat
+from casymda.visualization.canvas import web_canvas
 
+from .flatbuffers import flatbuffer_serializer
 
+
 class RunnableSimulation:
-    """ abstract base class for simulations to be run via a SimController """
+    """abstract base class for simulations to be run via a SimController"""
 
@@ -26,3 +29,3 @@ width: int
 class SimController:
-    """ wraps RunnableSimulation to be controlled by a sim-server """
+    """wraps RunnableSimulation to be controlled by a sim-server"""
 
@@ -72,4 +75,32 @@ def __init__(self, simulation: RunnableSimulation) -> None:
     def get_state_dumps(self):
-        return json.dumps(self.shared_state.copy())
+        state = self._get_state_dumps()
+        return json.dumps(state)
 
+    def get_partial_state_dumps(self):
+        state = self._get_partial_state_dumps()
+        return json.dumps(state)
+
+    def get_state_dumps_fb(self):
+        state = self._get_state_dumps()
+        return flatbuffer_serializer.serialize(state)
+
+    def get_partial_state_dumps_fb(self):
+        state = self._get_partial_state_dumps()
+        return flatbuffer_serializer.serialize(state)
+
+    def _get_state_dumps(self):
+        self.shared_state[web_canvas.UPDATED_KEY] = set()  # reset
+        state = self.shared_state.copy()
+        del state[web_canvas.UPDATED_KEY]
+        return state
+
+    def _get_partial_state_dumps(self):
+        updated_set = set(self.shared_state[web_canvas.UPDATED_KEY])
+        state = self.shared_state.copy()
+        self.shared_state[web_canvas.UPDATED_KEY] = set()  # reset
+        del state[web_canvas.UPDATED_KEY]
+        for not_updated in state.keys() - updated_set:
+            del state[not_updated]
+        return state
+
     def set_rt_factor(self, value: float):
@@ -76,0 +107,0 @@ return "set factor to " + str(self.factor.set_value(value))

Alert delta unavailable

Currently unable to show alert delta for PyPI packages.

Improved metrics

Total package byte prevSize

157557

49.96%

Number of package files

69

21.05%

Lines of code

3607

88.85%