From c236a1b00f125f3f4c9eac2d3ce0f12621d32fc7 Mon Sep 17 00:00:00 2001
From: Erik Demaine <edemaine@mit.edu>
Date: Sun, 12 Mar 2023 12:51:49 -0400
Subject: [PATCH] Unsorted edges_vertices to vertices_edges conversion

---
 dist/fold.js       | 40 +++++++++++++++++++++++++++++++++++++---
 doc/api.md         |  5 +++++
 src/convert.coffee |  8 ++++++++
 src/filter.coffee  | 15 +++++++++++++--
 4 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/dist/fold.js b/dist/fold.js
index 6445c71..b1c0df1 100644
--- a/dist/fold.js
+++ b/dist/fold.js
@@ -21,6 +21,15 @@ convert.edges_vertices_to_vertices_vertices_unsorted = function(fold) {
   return fold;
 };
 
+convert.edges_vertices_to_vertices_edges_unsorted = function(fold) {
+  /*
+  Invert edges_vertices into vertices_edges.
+  Works for abstract structures, so NOT SORTED.
+  */
+  fold.vertices_edges = filter.edges_vertices_to_vertices_edges(fold);
+  return fold;
+};
+
 convert.edges_vertices_to_vertices_vertices_sorted = function(fold) {
   /*
   Given a FOLD object with 2D `vertices_coords` and `edges_vertices` property
@@ -1398,7 +1407,7 @@ filter.edges_vertices_to_vertices_vertices = function(fold) {
   Works for abstract structures, so NOT SORTED.
   Use sort_vertices_vertices to sort in counterclockwise order.
   */
-  var edge, k, len, numVertices, ref, v, vertices_vertices, w;
+  var k, len, numVertices, ref, v, vertices_vertices, w;
   numVertices = filter.numVertices(fold);
   vertices_vertices = (function() {
     var k, ref, results;
@@ -1410,8 +1419,7 @@ filter.edges_vertices_to_vertices_vertices = function(fold) {
   })();
   ref = fold.edges_vertices;
   for (k = 0, len = ref.length; k < len; k++) {
-    edge = ref[k];
-    [v, w] = edge;
+    [v, w] = ref[k];
     while (v >= vertices_vertices.length) {
       vertices_vertices.push([]);
     }
@@ -1424,6 +1432,32 @@ filter.edges_vertices_to_vertices_vertices = function(fold) {
   return vertices_vertices;
 };
 
+filter.edges_vertices_to_vertices_edges = function(fold) {
+  /*
+  Invert edges_vertices into vertices_edges.
+  Works for abstract structures, so NOT SORTED in any sense.
+  */
+  var edge, k, l, len, len1, numVertices, ref, v, vertex, vertices, vertices_edges;
+  numVertices = filter.numVertices(fold);
+  vertices_edges = (function() {
+    var k, ref, results;
+    results = [];
+    for (v = k = 0, ref = numVertices; (0 <= ref ? k < ref : k > ref); v = 0 <= ref ? ++k : --k) {
+      results.push([]);
+    }
+    return results;
+  })();
+  ref = fold.edges_vertices;
+  for (edge = k = 0, len = ref.length; k < len; edge = ++k) {
+    vertices = ref[edge];
+    for (l = 0, len1 = vertices.length; l < len1; l++) {
+      vertex = vertices[l];
+      vertices_edges[vertex].push(edge);
+    }
+  }
+  return vertices_edges;
+};
+
 
 },{"./geom":4}],4:[function(require,module,exports){
   /* BASIC GEOMETRY */
diff --git a/doc/api.md b/doc/api.md
index 522a07c..dea4d33 100644
--- a/doc/api.md
+++ b/doc/api.md
@@ -87,6 +87,11 @@ for details.
   endpoints), automatically computes the `vertices_vertices` property.
   However, note that the `vertices_vertices` arrays will *not* be sorted
   in counterclockwise order.
+* `FOLD.convert.edges_vertices_to_vertices_edges_unsorted(fold)`:
+  Given a FOLD object with `edges_vertices` property (defining edge
+  endpoints), automatically computes the inverse `vertices_edges` property.
+  However, note that the `vertices_edges` arrays will *not* be sorted
+  in counterclockwise order.
 * `FOLD.convert.edges_vertices_to_vertices_vertices_sorted(fold)`:
   Given a FOLD object with 2D `vertices_coords` and `edges_vertices` property
   (defining edge endpoints), automatically computes the `vertices_vertices`
diff --git a/src/convert.coffee b/src/convert.coffee
index f50bdd1..72a2f75 100644
--- a/src/convert.coffee
+++ b/src/convert.coffee
@@ -12,6 +12,14 @@ convert.edges_vertices_to_vertices_vertices_unsorted = (fold) ->
   fold.vertices_vertices = filter.edges_vertices_to_vertices_vertices fold
   fold
 
+convert.edges_vertices_to_vertices_edges_unsorted = (fold) ->
+  ###
+  Invert edges_vertices into vertices_edges.
+  Works for abstract structures, so NOT SORTED.
+  ###
+  fold.vertices_edges = filter.edges_vertices_to_vertices_edges fold
+  fold
+
 convert.edges_vertices_to_vertices_vertices_sorted = (fold) ->
   ###
   Given a FOLD object with 2D `vertices_coords` and `edges_vertices` property
diff --git a/src/filter.coffee b/src/filter.coffee
index 35e4168..03e2690 100644
--- a/src/filter.coffee
+++ b/src/filter.coffee
@@ -405,8 +405,7 @@ filter.edges_vertices_to_vertices_vertices = (fold) ->
   ###
   numVertices = filter.numVertices fold
   vertices_vertices = ([] for v in [0...numVertices])
-  for edge in fold.edges_vertices
-    [v, w] = edge
+  for [v, w] in fold.edges_vertices
     while v >= vertices_vertices.length
       vertices_vertices.push []
     while w >= vertices_vertices.length
@@ -414,3 +413,15 @@ filter.edges_vertices_to_vertices_vertices = (fold) ->
     vertices_vertices[v].push w
     vertices_vertices[w].push v
   vertices_vertices
+
+filter.edges_vertices_to_vertices_edges = (fold) ->
+  ###
+  Invert edges_vertices into vertices_edges.
+  Works for abstract structures, so NOT SORTED in any sense.
+  ###
+  numVertices = filter.numVertices fold
+  vertices_edges = ([] for v in [0...numVertices])
+  for vertices, edge in fold.edges_vertices
+    for vertex in vertices
+      vertices_edges[vertex].push edge
+  vertices_edges