kitchen-simulator 2.0.0 → 2.0.1-test.1

package/lib/utils/get-edges-of-subgraphs.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function getEdgesOfSubgraphs(subgraphs, graph) {
+  var edges = [];
+  subgraphs.forEach(function (component) {
+    edges.push([]);
+    var vertices = getVerticesFromBiconnectedComponent(component);
+    var inserted = [];
+    vertices.forEach(function (vertex) {
+      var adjacents = graph.adj[vertex];
+      adjacents.forEach(function (adj) {
+        if (vertex <= adj && vertices.has(adj)) {
+          edges[edges.length - 1].push([vertex, adj]);
+        }
+      });
+    });
+  });
+  return edges;
+}
+function getVerticesFromBiconnectedComponent(component) {
+  var vertices = new Set();
+  component.forEach(function (edge) {
+    vertices.add(edge.u);
+    vertices.add(edge.v);
+  });
+  return vertices;
+}
+var _default = exports["default"] = getEdgesOfSubgraphs;
+module.exports = exports.default;

package/lib/utils/graph-cycles.js

@@ -0,0 +1,239 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+/**
+ * UTILS
+ */
+
+function sub(v1, v2) {
+  return [v1[0] - v2[0], v1[1] - v2[1]];
+}
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+
+/**
+ * CYCLES
+ */
+
+function compute_ev_mapping(EV) {
+  var ev_mapping = EV.map(function (ev) {
+    return {
+      ev: ev,
+      color: 0,
+      direction: -1
+    };
+  });
+  return ev_mapping;
+}
+function compute_angle(P, V) {
+  var point = sub(V, P);
+  var angle = Math.atan2(point[1], point[0]);
+  return angle;
+}
+function compute_incidences(V, EV) {
+  var incidences = V.map(function (vertex, i) {
+    var incidence = [];
+    EV.forEach(function (edge, j) {
+      var endpoint;
+      var position;
+      if (edge[0] === i) {
+        endpoint = edge[1];
+        position = 1;
+      }
+      if (edge[1] === i) {
+        endpoint = edge[0];
+        position = 0;
+      }
+      endpoint !== undefined && incidence.push({
+        index: j,
+        endpoint: endpoint,
+        angle: compute_angle(vertex, V[endpoint]),
+        edge: edge,
+        position: position
+      });
+    });
+    incidence.sort(function (i1, i2) {
+      return i2.angle - i1.angle;
+    });
+    return incidence;
+  });
+  return incidences;
+}
+function get_starting_edge(incidences, ev_mapping) {
+  var e;
+  var position;
+  var direction;
+  for (e = 0; e < ev_mapping.length; e += 1) {
+    if (ev_mapping[e].color < 2) {
+      direction = -1 * ev_mapping[e].direction;
+      color(ev_mapping, e, direction);
+      return {
+        edge: e,
+        direction: direction,
+        position: direction === -1 ? 0 : 1
+      };
+    }
+  }
+}
+function get_next_edge(incidences, edge, position, EV) {
+  var items = incidences[EV[edge][position]];
+  //console.log(items, incidences, EV, edge, position);
+  var n_items = items.length;
+  var item;
+  var out;
+  var j;
+  for (j = 0; j < n_items; j += 1) {
+    item = items[j];
+    if (item.index === edge) {
+      out = items[mod(j + 1, items.length)];
+      return {
+        edge: out.index,
+        vertex: out.endpoint,
+        position: out.position,
+        direction: out.position ? 1 : -1
+      };
+    }
+  }
+}
+function color(ev_mapping, index, direction) {
+  ev_mapping[index].color += 1;
+  ev_mapping[index].direction = direction;
+}
+function find_cycles(V, EV) {
+  var ev_mapping = compute_ev_mapping(EV);
+  var incidences = compute_incidences(V, EV);
+  var V_cycles = [];
+  var E_cycles = [];
+  var dir_E_cycles = [];
+  var V_cycle;
+  var E_cycle;
+  var dir_E_cycle;
+  var next;
+  var counter = 0;
+  var start = get_starting_edge(incidences, ev_mapping);
+  while (start !== undefined) {
+    V_cycle = [EV[start.edge][mod(start.position + 1, 2)], EV[start.edge][start.position]];
+    E_cycle = [start.edge];
+    dir_E_cycle = [start.direction];
+    next = get_next_edge(incidences, start.edge, start.position, EV);
+    while (next.edge !== start.edge) {
+      V_cycle.push(next.vertex);
+      E_cycle.push(next.edge);
+      dir_E_cycle.push(next.direction);
+      color(ev_mapping, next.edge, next.direction);
+      next = get_next_edge(incidences, next.edge, next.position, EV);
+    }
+    E_cycles.push(E_cycle);
+    V_cycles.push(V_cycle);
+    dir_E_cycles.push(dir_E_cycle);
+
+    //console.log('############## CYCLE ', ++counter)
+    //console.log('EDGES:', E_cycle)
+    //console.log('VERTICES:', V_cycle)
+    //console.log('START', 'edge:', start.edge, 'position:', start.position)
+    //console.log('COUNTER:', ev_mapping.map(e => e.color), ev_mapping.map(e => e.color).reduce((a, b) => a + b));
+    //console.log('\n')
+
+    start = get_starting_edge(incidences, ev_mapping);
+  }
+  return {
+    v_cycles: V_cycles,
+    e_cycles: E_cycles,
+    dir_e_cycles: dir_E_cycles,
+    ev_mapping: ev_mapping
+  };
+}
+function find_short_cycles_indexes(v_cycles, e_cycles) {
+  var indexes = [];
+  var e_cycle;
+  var v_cycle;
+  var i;
+  for (i = 0; i < e_cycles.length; i += 1) {
+    e_cycle = e_cycles[i];
+    v_cycle = v_cycles[i];
+    if (e_cycle.length < 3 || v_cycle[0] !== v_cycle[v_cycle.length - 1]) {
+      indexes.push(i);
+    }
+  }
+  return indexes;
+}
+function find_inner_cycles(V, EV) {
+  var cycles = find_cycles(V, EV);
+  var v_cycles = cycles.v_cycles;
+  var e_cycles = cycles.e_cycles;
+  var short_cycles_indexes = find_short_cycles_indexes(v_cycles, e_cycles);
+  short_cycles_indexes.forEach(function (indx) {
+    v_cycles.splice(indx, 1);
+    e_cycles.splice(indx, 1);
+  });
+  var dir_e_cycles = cycles.dir_e_cycles;
+  var rooms_values = cycles.e_cycles.map(function (cycle, i) {
+    return cycle.map(function (edge, j) {
+      var v1;
+      var v2;
+      var dir = dir_e_cycles[i][j] > 0;
+      if (dir > 0) {
+        v1 = EV[edge][0];
+        v2 = EV[edge][1];
+      } else {
+        v1 = EV[edge][1];
+        v2 = EV[edge][0];
+      }
+      return (V[v2][0] - V[v1][0]) * (V[v2][1] + V[v1][1]);
+    });
+  });
+  var rooms_sums = rooms_values.map(function (room) {
+    return room.reduce(function (a, b) {
+      return a + b;
+    });
+  });
+  var positive_count = rooms_sums.filter(function (sum) {
+    return sum > 0;
+  }).length;
+  var negative_count = rooms_sums.length - positive_count;
+  var rm_neg = positive_count >= negative_count ? 1 : -1;
+  return {
+    v_cycles: cycles.v_cycles.filter(function (v, i) {
+      return rm_neg * rooms_sums[i] > 0;
+    }),
+    e_cycles: cycles.e_cycles.filter(function (v, i) {
+      return rm_neg * rooms_sums[i] > 0;
+    }),
+    ev_mapping: cycles.ev_mapping
+  };
+}
+
+// export default find_inner_cycles;
+var _default = exports["default"] = find_inner_cycles;
+/**
+ * DATA
+ */
+// let V = [[0.5774, 1.0], [1.0, 1.0], [1.1547, 0.0], [1.0, 0.0], [0.0, 0.0], [0.0, 0.732], [1.0, 0.1547], [0.732, 0.0], [1.0491, 0.183], [-0.317, 0.549], [1.0, 0.268], [0.183, -0.3169], [0.5491, 1.049], [0.4642, 1.0], [0.0, -0.4226], [0.0, 1.0]]
+// let EV = [[0, 1], [2, 3], [5, 4], [7, 6], [2, 8], [3, 6], [4, 9], [0, 10], [9, 5], [8, 10], [7, 11], [12, 13], [6, 8], [6, 10], [4, 7], [4, 11], [4, 14], [5, 15], [11, 14], [0, 12], [13, 15], [0, 13], [1, 10], [3, 7], [5, 13]]
+// let V = [[0,0],[10,0],[10,10],[0,10], [100,100],[110,100],[110,110],[100,110], [5,0], [5,10]]
+// let V = [[0,0.5],[12,-0.7],[14,14],[-2,10], [103,106],[117,98],[96,112],[104,109], [5.5,0.8], [4.8,10.5]]
+// let EV = [[3,9],[9,2],[2,1],[1,8],[8,0],[0,3],[8,9]] // IT WORKS
+// let EV = [[3,9],[9,2],[2,1],[1,8],[8,0],[0,3],[8,9], [5,6], [6,7], [2,5]] // IT DOESN'T WORK
+// let EV = [[3,2],[2,1],[1,0],[0,3]] // IT WORKS
+// let EV = [[2,3],[1,2],[0,1],[3,0]] // IT WORKS
+// let EV = [[2,3],[1,2],[0,1],[3,0],[6,7],[5,6],[4,5],[7,4]] // IT WORKS
+// let EV = [[3,2],[2,1],[1,0],[0,3],[7,6],[6,5],[5,4],[4,7]] // IT WORKS
+// let V = [[2,5],[5,6],[10,6.8],[23,8],[9.6,11.3],[20,15],[25,16],[29,18],[30,22],[4,11],[6,10],[24,25],[18,20],[27,7]]
+// let EV = [[0,1],[10,0],[9,10],[9,1],[1,2],[4,2],[3,13],[2,3],[4,5],[5,6],[6,7],[12,5],[12,11],[11,6],[11,8],[7,8],[9,4]]
+/**
+ * MAIN
+ */
+// let cycles_data = find_inner_cycles(V, EV)
+// console.log('############## OUTPUT')
+// console.log('EDGES:')
+// console.log(cycles_data.e_cycles)
+// console.log('\n')
+// console.log('VERTICES:')
+// console.log(cycles_data.v_cycles)
+// console.log('\n')
+// console.log(cycles_data.ev_mapping.every(m => m.color === 2))
+module.exports = exports.default;

package/lib/utils/graph-inner-cycles.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateInnerCycles = calculateInnerCycles;
+exports.isClockWiseOrder = isClockWiseOrder;
+var _graph = _interopRequireDefault(require("./graph"));
+var _getEdgesOfSubgraphs = _interopRequireDefault(require("./get-edges-of-subgraphs"));
+var _graphCycles = _interopRequireDefault(require("./graph-cycles"));
+var _immutable = require("immutable");
+function calculateInnerCycles(verticesArray, edgesArray) {
+  var innerCycles = new _immutable.List();
+  var graph = new _graph["default"](verticesArray.length);
+  edgesArray.forEach(function (line) {
+    graph.addEdge(line[0], line[1]);
+    graph.addEdge(line[1], line[0]);
+  });
+  graph.BCC();
+  var subgraphs = graph.subgraphs.filter(function (subgraph) {
+    return subgraph.length >= 3;
+  });
+  var edgesOfSubgraphsArray = (0, _getEdgesOfSubgraphs["default"])(subgraphs, graph);
+  var edges = [];
+  edgesOfSubgraphsArray.forEach(function (es) {
+    es.forEach(function (edge) {
+      return edges.push(edge);
+    });
+  });
+  var cycles = (0, _graphCycles["default"])(verticesArray, edges);
+  cycles.v_cycles.forEach(function (cycle) {
+    cycle.shift();
+    innerCycles = innerCycles.push(cycle);
+  });
+  return innerCycles;
+}
+function isClockWiseOrder(innerCycleWithCoords) {
+  // See: https://stackoverflow.com/a/1165943 and http://blog.element84.com/polygon-winding.html
+
+  var i = 0;
+  var twiceEnclosedArea = 0;
+  var size = innerCycleWithCoords.size;
+  for (i = 0; i < size; i++) {
+    var _innerCycleWithCoords = innerCycleWithCoords.get(i),
+      x1 = _innerCycleWithCoords.x,
+      y1 = _innerCycleWithCoords.y;
+    var _innerCycleWithCoords2 = innerCycleWithCoords.get((i + 1) % size),
+      x2 = _innerCycleWithCoords2.x,
+      y2 = _innerCycleWithCoords2.y;
+    twiceEnclosedArea += (x2 - x1) * (y2 + y1);
+  }
+  return twiceEnclosedArea > 0;
+}

package/lib/utils/graph.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+//JS porting of this code http://www.geeksforgeeks.org/biconnected-components/
+
+function create_array(length) {
+  var array = [];
+  for (var i = 0; i < length; ++i) {
+    array.push([]);
+  }
+  return array;
+}
+var Edge = /*#__PURE__*/(0, _createClass2["default"])(function Edge(u, v) {
+  (0, _classCallCheck2["default"])(this, Edge);
+  this.u = u;
+  this.v = v;
+});
+var Graph = /*#__PURE__*/function () {
+  function Graph(v) {
+    (0, _classCallCheck2["default"])(this, Graph);
+    this.count = 0; // count is number of biconnected components
+    this.subgraphs = []; //biconnected components
+    this.time = 0; // time is used to find discovery times
+
+    this.V = v; // No. of vertices
+    this.E = 0; // No. of Edges
+    this.adj = []; // Adjacency List
+
+    this.adj = create_array(v);
+  }
+
+  //Function to add an edge into the graph
+  return (0, _createClass2["default"])(Graph, [{
+    key: "addEdge",
+    value: function addEdge(v, w) {
+      this.adj[v].push(w);
+      this.E++;
+    }
+
+    // A recursive function that finds and prints strongly connected
+    // components using DFS traversal
+    // u --> The vertex to be visited next
+    // disc[] --> Stores discovery times of visited vertices
+    // low[] -- >> earliest visited vertex (the vertex with minimum
+    //             discovery time) that can be reached from subtree
+    //             rooted with current vertex
+    // *st -- >> To store visited edges
+    // // A recursive function that finds and prints strongly connected
+    // components using DFS traversal
+    // u --> The vertex to be visited next
+    // disc[] --> Stores discovery times of visited vertices
+    // low[] -- >> earliest visited vertex (the vertex with minimum
+    //             discovery time) that can be reached from subtree
+    //             rooted with current vertex
+    // *st -- >> To store visited edges
+  }, {
+    key: "_BCCUtil",
+    value: function _BCCUtil(u, disc, low, st, parent) {
+      var _this = this;
+      // Initialize discovery time and low value
+      disc[u] = low[u] = ++this.time;
+      this.children = 0;
+
+      // Go through all vertices adjacent to this
+      // v is current adjacent of 'u'
+      this.adj[u].forEach(function (v) {
+        // If v is not visited yet, then recur for it
+        if (disc[v] == -1) {
+          _this.children++;
+          parent[v] = u;
+
+          // store the edge in stack
+          st.push(new Edge(u, v));
+          _this._BCCUtil(v, disc, low, st, parent);
+
+          // Check if the subtree rooted with 'v' has a
+          // connection to one of the ancestors of 'u'
+          // Case 1 -- per Strongly Connected Components Article
+          if (low[u] > low[v]) low[u] = low[v];
+
+          // If u is an articulation point,
+          // pop all edges from stack till u -- v
+          if (disc[u] == 1 && _this.children > 1 || disc[u] > 1 && low[v] >= disc[u]) {
+            var subgraph = [];
+            while (st[st.length - 1].u != u || st[st.length - 1].v != v) {
+              subgraph.push(st[st.length - 1]);
+              //console.log(st[st.length - 1].u + "--" + st[st.length - 1].v + " ");
+              st.splice(st.length - 1, 1);
+            }
+            subgraph.push(st[st.length - 1]);
+            //console.log(st[st.length - 1].u + "--" + st[st.length - 1].v + " ");
+            _this.subgraphs.push(subgraph);
+            subgraph = [];
+            //console.log()
+            st.splice(st.length - 1, 1);
+            _this.count++;
+          }
+        }
+
+        // Update low value of 'u' only of 'v' is still in stack
+        // (i.e. it's a back edge, not cross edge).
+        // Case 2 -- per Strongly Connected Components Article
+        else if (v != parent[u] && disc[v] < low[u]) {
+          if (low[u] > disc[v]) low[u] = disc[v];
+          st.push(new Edge(u, v));
+        }
+      });
+    }
+  }, {
+    key: "BCC",
+    value: function BCC() {
+      var V = this.V;
+      var disc = create_array(V);
+      var low = create_array(V);
+      var parent = create_array(V);
+      var st = [];
+
+      // Initialize disc and low, and parent arrays
+      for (var i = 0; i < V; i++) {
+        disc[i] = -1;
+        low[i] = -1;
+        parent[i] = -1;
+      }
+      for (var _i = 0; _i < V; _i++) {
+        if (disc[_i] == -1) this._BCCUtil(_i, disc, low, st, parent);
+        var j = 0;
+
+        // If stack is not empty, pop all edges from stack
+        var subgraph = [];
+        while (st.length > 0) {
+          j = 1;
+          subgraph.push(st[st.length - 1]);
+          //console.log(st[st.length - 1].u + "--" + st[st.length - 1].v + " ");
+          st.splice(st.length - 1, 1);
+        }
+        if (j == 1) {
+          this.subgraphs.push(subgraph);
+          subgraph = [];
+          //console.log();
+          this.count++;
+        }
+      }
+    }
+  }]);
+}();
+var _default = exports["default"] = Graph;
+module.exports = exports.default;