kitchen-simulator 5.0.0-test.4 → 5.0.0-test.5

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

@@ -1,29 +0,0 @@
-function getEdgesOfSubgraphs(subgraphs, graph) {
-  let edges = [];
-
-  subgraphs.forEach(component => {
-    edges.push([]);
-    let vertices = getVerticesFromBiconnectedComponent(component);
-    let inserted = [];
-    vertices.forEach(vertex => {
-      let adjacents = graph.adj[vertex];
-      adjacents.forEach(adj => {
-        if (vertex <= adj && vertices.has(adj)) {
-          edges[edges.length - 1].push([vertex, adj]);
-        }
-      });
-    });
-  });
-  return edges;
-}
-
-function getVerticesFromBiconnectedComponent(component) {
-  let vertices = new Set();
-  component.forEach(edge => {
-    vertices.add(edge.u);
-    vertices.add(edge.v);
-  });
-  return vertices;
-}
-
-module.exports = getEdgesOfSubgraphs;

package/src/utils/graph-cycles.js

@@ -1,259 +0,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) {
-  let ev_mapping = EV.map(function (ev) {
-    return {
-      ev: ev,
-      color: 0,
-      direction: -1
-    };
-  });
-
-  return ev_mapping;
-}
-
-function compute_angle(P, V) {
-  let point = sub(V, P);
-  let angle = Math.atan2(point[1], point[0]);
-  return angle;
-}
-
-function compute_incidences(V, EV) {
-  let incidences = V.map(function (vertex, i) {
-    let incidence = [];
-    EV.forEach(function (edge, j) {
-      let endpoint;
-      let 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) {
-  let e;
-  let position;
-  let 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) {
-  let items = incidences[EV[edge][position]];
-  //console.log(items, incidences, EV, edge, position);
-  let n_items = items.length;
-  let item;
-  let out;
-  let 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) {
-  let ev_mapping = compute_ev_mapping(EV);
-  let incidences = compute_incidences(V, EV);
-  let V_cycles = [];
-  let E_cycles = [];
-  let dir_E_cycles = [];
-  let V_cycle;
-  let E_cycle;
-  let dir_E_cycle;
-  let next;
-  let counter = 0;
-  let 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) {
-  let indexes = [];
-  let e_cycle;
-  let v_cycle;
-  let 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) {
-  let cycles = find_cycles(V, EV);
-  let v_cycles = cycles.v_cycles;
-  let e_cycles = cycles.e_cycles;
-  let short_cycles_indexes = find_short_cycles_indexes(v_cycles, e_cycles);
-  short_cycles_indexes.forEach(indx => {
-    v_cycles.splice(indx, 1);
-    e_cycles.splice(indx, 1);
-  });
-  let dir_e_cycles = cycles.dir_e_cycles;
-  let rooms_values = cycles.e_cycles.map((cycle, i) =>
-    cycle.map(function (edge, j) {
-      let v1;
-      let v2;
-
-      let 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]);
-    })
-  );
-
-  let rooms_sums = rooms_values.map(room => room.reduce((a, b) => a + b));
-
-  let positive_count = rooms_sums.filter(sum => sum > 0).length;
-  let negative_count = rooms_sums.length - positive_count;
-
-  let rm_neg = positive_count >= negative_count ? 1 : -1;
-
-  return {
-    v_cycles: cycles.v_cycles.filter((v, i) => rm_neg * rooms_sums[i] > 0),
-    e_cycles: cycles.e_cycles.filter((v, i) => rm_neg * rooms_sums[i] > 0),
-    ev_mapping: cycles.ev_mapping
-  };
-}
-
-// export default find_inner_cycles;
-module.exports = 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))

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

@@ -1,49 +0,0 @@
-import Graph from './graph';
-import getEdgesOfSubgraphs from './get-edges-of-subgraphs';
-import graphCycles from './graph-cycles';
-import { List } from 'immutable';
-
-export function calculateInnerCycles(verticesArray, edgesArray) {
-  let innerCycles = new List();
-
-  let graph = new Graph(verticesArray.length);
-  edgesArray.forEach(line => {
-    graph.addEdge(line[0], line[1]);
-    graph.addEdge(line[1], line[0]);
-  });
-
-  graph.BCC();
-
-  let subgraphs = graph.subgraphs.filter(subgraph => subgraph.length >= 3);
-  let edgesOfSubgraphsArray = getEdgesOfSubgraphs(subgraphs, graph);
-
-  let edges = [];
-  edgesOfSubgraphsArray.forEach(es => {
-    es.forEach(edge => edges.push(edge));
-  });
-
-  let cycles = graphCycles(verticesArray, edges);
-  cycles.v_cycles.forEach(cycle => {
-    cycle.shift();
-    innerCycles = innerCycles.push(cycle);
-  });
-
-  return innerCycles;
-}
-
-export function isClockWiseOrder(innerCycleWithCoords) {
-  // See: https://stackoverflow.com/a/1165943 and http://blog.element84.com/polygon-winding.html
-
-  let i = 0;
-  let twiceEnclosedArea = 0;
-  let size = innerCycleWithCoords.size;
-
-  for (i = 0; i < size; i++) {
-    let { x: x1, y: y1 } = innerCycleWithCoords.get(i);
-    let { x: x2, y: y2 } = innerCycleWithCoords.get((i + 1) % size);
-
-    twiceEnclosedArea += (x2 - x1) * (y2 + y1);
-  }
-
-  return twiceEnclosedArea > 0;
-}

package/src/utils/graph.js

@@ -1,147 +0,0 @@
-//JS porting of this code http://www.geeksforgeeks.org/biconnected-components/
-
-function create_array(length) {
-  let array = [];
-  for (let i = 0; i < length; ++i) {
-    array.push([]);
-  }
-  return array;
-}
-
-class Edge {
-  constructor(u, v) {
-    this.u = u;
-    this.v = v;
-  }
-}
-
-class Graph {
-  constructor(v) {
-    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
-  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
-  _BCCUtil(u, disc, low, st, parent) {
-    // 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(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])
-        ) {
-          let 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));
-      }
-    });
-  }
-
-  BCC() {
-    let V = this.V;
-    let disc = create_array(V);
-    let low = create_array(V);
-    let parent = create_array(V);
-    let st = [];
-
-    // Initialize disc and low, and parent arrays
-    for (let i = 0; i < V; i++) {
-      disc[i] = -1;
-      low[i] = -1;
-      parent[i] = -1;
-    }
-
-    for (let i = 0; i < V; i++) {
-      if (disc[i] == -1) this._BCCUtil(i, disc, low, st, parent);
-
-      let j = 0;
-
-      // If stack is not empty, pop all edges from stack
-      let 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++;
-      }
-    }
-  }
-}
-
-module.exports = Graph;