4 map merges, nextmap and backmap, simple and complex

package.json

@@ -35,19 +35,11 @@
 	"bugs": {
 		"url": "https://github.com/robbykraft/Origami/issues"
 	},
-	"dependencies": {},
 	"devDependencies": {
-		"@babel/preset-env": "^7.11.0",
-		"@rollup/plugin-babel": "^5.2.0",
-		"@rollup/plugin-node-resolve": "^9.0.0",
-		"eslint": "^7.7.0",
-		"eslint-config-airbnb-base": "^14.2.0",
-		"eslint-plugin-import": "^2.22.0",
-		"jest": "^26.4.2",
+		"@rollup/plugin-json": "^4.1.0",
+		"jest": "^26.6.3",
 		"rollup": "^2.26.5",
-		"rollup-plugin-cleanup": "^3.1.1",
-		"rollup-plugin-terser": "^7.0.0",
-		"rollup-plugin-string": "^3.0.0",
+		"rollup-plugin-cleanup": "^3.2.1",
 		"xmldom": "^0.3.0"
 	},
 	"jest": {

rollup.config.js

@@ -1,8 +1,5 @@
-import babel from "@rollup/plugin-babel";
-import { terser } from "rollup-plugin-terser";
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import cleanup from "rollup-plugin-cleanup";
-import { string } from "rollup-plugin-string";
+import json from "@rollup/plugin-json";
+import cleanup from "rollup-plugin-cleanup"
 
 const version = "0.1.91";
 
@@ -16,17 +13,7 @@ module.exports = [{
     banner: `/* Rabbit Ear v${version} (c) Robby Kraft, MIT License */`,
   },
   plugins: [
-    nodeResolve(),
-    // babel({
-    //   babelHelpers: "bundled",
-    //   presets: ["@babel/preset-env"]
-    // }),
-    cleanup(),
-    // terser({
-    //   compress: { properties: false }
-    // }),
-    string({
-      include: ["**/*.json", "**/*.fold"], // allows .fold files to be imported as a module
-    }),
-  ],
+    json(),
+    cleanup()
+  ]
 }];

src/graph/add/split_edge.js

@@ -190,15 +190,30 @@ const split_edge = function (graph, old_edge, coords) {
   }
   // todo: copy over edgeOrders. don't need to do this with faceOrders
   // remove old data
+	// todo: make the map include the new data
+	// shift the map over to the new format
   const edge_map = remove(graph, EDGES, [ old_edge ]);
-  return {
+	// we had to run "remove" with the new edges added. to return the change info,
+	// we need to adjust the map to exclude these edges.
+	// we can count on new_edges being sorted
+	// new_edges.reverse().forEach(i => edge_map.splice(i, 1));
+  // new_edges.forEach((_, i) => { new_edges[i] = new_edges[i] - 1; });
+  new_edges.forEach((_, i) => { new_edges[i] = edge_map[new_edges[i]]; });
+	edge_map.splice(-2);
+	return {
     vertex,
     edges: {
       map: edge_map,
       replace: {
         old: old_edge,
         new: new_edges,
       },
+			remove: {
+				map: edge_map,
+			},
+			add: {
+        map: new_edges,
+			},
     },
   };
 };

src/graph/add/split_face.js

@@ -113,16 +113,20 @@ const split_convex_face = (graph, face, vector, origin) => {
     el.edge = edge_map[el.edge];
     // split the edge (modifying the graph), and store the changes so that during
     // the next loop the second edge to split will be updated to the new index
-    const result = split_edge(graph, el.edge, el.coords);
-    // store changes to the graph for future iterations
-    changes.push(result);
-    // update the other details of the changes
-    // "old" is the index before the operation. update it to relate to the current graph
-    result.edges.replace.old = edge_map.indexOf(result.edges.replace.old);
+		const result = split_edge(graph, el.edge, el.coords);
     // these update normally
+		if (i === 1) {
+		  console.log("second round", changes[0], result.edges.map);
+		}
     changes.forEach(prev => [0, 1].forEach((_, i) => {
-      prev.edges.replace.new[i] = result.edges.map[result.edges.replace.new[i]];
+			prev.edges.replace.new[i] = result.edges.map[prev.edges.replace.new[i]];
+		//  prev.edges.replace.new[i] = result.edges.map[result.edges.replace.new[i]];
     }));
+    // update the other details of the changes
+    // "old" is the index before the operation. update it to relate to the current graph
+		result.edges.replace.old = edge_map.indexOf(result.edges.replace.old);
+    // store changes to the graph for future iterations
+    changes.push(result);
   });
   vertices.push(...changes.map(result => result.vertex));
   // the indices of our new components

src/graph/fragment.js

@@ -68,6 +68,11 @@ const fragment_graph = (graph, epsilon = math.core.EPSILON) => {
     edges_vertices: graph.edges_vertices,
     edges_coords
   }, epsilon);
+  // exit early
+  if (edges_intersections.reduce(fn_cat, []).filter(fn_def).length === 0 &&
+  edges_collinear_vertices.reduce(fn_cat, []).filter(fn_def).length === 0) {
+    return;
+  }
   // remember, edges_intersections contains intersections [x,y] points
   // each one appears twice (both edges that intersect) and is the same
   // object, shallow pointer.
@@ -77,11 +82,7 @@ const fragment_graph = (graph, epsilon = math.core.EPSILON) => {
   // when we get to the second appearance of the same point, it will have
   // been replaced with the index, so we can skip it. (check length of
   // item, 2=point, 1=index)
-  if (edges_intersections.reduce(fn_cat, []).filter(fn_def).length === 0 &&
-  edges_collinear_vertices.reduce(fn_cat, []).filter(fn_def).length === 0) {
-    return;
-  }
-
+  const counts = { vertices: graph.vertices_coords.length };
   // add new vertices (intersection points) to the graph
   edges_intersections
     .forEach(edge => edge
@@ -104,14 +105,18 @@ const fragment_graph = (graph, epsilon = math.core.EPSILON) => {
 
   const edges_intersections_flat = edges_intersections
     .map(arr => arr.filter(fn_def));
-
+  // add lists of vertices into each element in edges_vertices
+  // edges verts now contains an illegal arrangement of more than 2 verts
+  // to be resolved below
   graph.edges_vertices.forEach((verts, i) => verts
     .push(...edges_intersections_flat[i], ...edges_collinear_vertices[i]));
     // .push(...edges_intersections_flat[i]));
 
   graph.edges_vertices.forEach((edge, i) => {
-    graph.edges_vertices[i] = sort_vertices_along_vector({ vertices_coords: graph.vertices_coords }, edge, edges_vector[i]);
-  })
+    graph.edges_vertices[i] = sort_vertices_along_vector({
+      vertices_coords: graph.vertices_coords
+    }, edge, edges_vector[i]);
+  });
 
   // edge_map is length edges_vertices in the new, fragmented graph.
   // the value at each index is the edge that this edge was formed from.
@@ -130,7 +135,16 @@ const fragment_graph = (graph, epsilon = math.core.EPSILON) => {
   if (graph.edges_foldAngle) {
     graph.edges_foldAngle = edge_map.map(i => graph.edges_foldAngle[i] || 0);
   }
-  return graph;
+  return {
+    vertices: {
+      new: Array.from(Array(graph.vertices_coords.length - counts.vertices))
+        .map((_, i) => counts.vertices + i),
+    },
+    edges: {
+      backmap: edge_map
+    }
+  };
+  // return graph;
 };
 
 const fragment_keep_keys = [

src/graph/index.js

@@ -9,6 +9,7 @@ import * as nearest from "./nearest";
 import * as fold_object from "./fold_spec";
 import * as sort from "./sort";
 import * as span from "./span";
+import * as maps from "./maps";
 import count from "./count";
 import implied from "./count_implied";
 import remove from "./remove";
@@ -25,7 +26,7 @@ import add_vertices_split_edges from "./add/add_vertices_split_edges";
 import add_edges from "./add/add_edges";
 import split_edge from "./add/split_edge";
 import split_face from "./add/split_face";
-import flat_fold from "./flat_fold";
+import flat_fold from "./flat_fold/index";
 // clean things
 import * as remove_methods from "./clean/index"
 import clean from "./clean/clean";
@@ -77,6 +78,7 @@ export default Object.assign(Object.create(null), {
   fold_object,
   sort,
   span,
+  maps,
   // clean things
   remove_methods,
   vertices_isolated,

src/graph/maps.js

@@ -20,6 +20,48 @@ export const merge_maps = (...maps) => {
   });
   return solution;
 };
+
+export const merge_simple_nextmaps = (...maps) => {
+  if (maps.length === 0) { return; }
+	const solution = maps[0].map((_, i) => i);
+	maps.forEach(map => solution.forEach((s, i) => { solution[i] = map[s]; }));
+	return solution;
+};
+
+export const merge_nextmaps = (...maps) => {
+  if (maps.length === 0) { return; }
+	const solution = maps[0].map((_, i) => [i]);
+	maps.forEach(map => {
+		solution.forEach((s, i) => s.forEach((indx,j) => { solution[i][j] = map[indx]; }));
+		solution.forEach((arr, i) => { solution[i] = arr.reduce((a,b) => a.concat(b), []); });
+	});
+	return solution;
+};
+
+export const merge_simple_backmaps = (...maps) => {
+  if (maps.length === 0) { return; }
+	let solution = maps[0].map((_, i) => i);
+	maps.forEach((map, i) => {
+		const next = map.map(n => solution[n]);
+	  solution = next;
+	});
+  return solution;
+};
+
+export const merge_backmaps = (...maps) => {
+  if (maps.length === 0) { return; }
+  let solution = maps[0].reduce((a, b) => a.concat(b), []).map((_, i) => [i]);
+  maps.forEach((map, i) => {
+		let next = [];
+	  map.forEach((el, j) => {
+      if (typeof el === "number") { next[j] = solution[el]; }
+			else { next[j] = el.map(n => solution[n]).reduce((a,b) => a.concat(b), []); }
+		});
+		solution = next;
+	});
+	return solution;
+};
+
 // initial:
 // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 // maps:

src/index.js

@@ -12,8 +12,8 @@
 import { isBrowser, isWebWorker, isNode } from "./environment/detect";
 import math from "./math";
 import root from "./root";
-import use from "./use";
-import graph_methods from "./graph";
+import use from "./use/index";
+import graph_methods from "./graph/index";
 // build objects
 import Constructors from "./constructors";
 // prototypes
@@ -26,8 +26,8 @@ import { fold_object_certainty } from "./graph/fold_spec";
 // static constructors for prototypes
 import create from "./graph/create";
 // top level things
-import axiom from "./axioms";
-import text from "./text";
+import axiom from "./axioms/index";
+import text from "./text/index";
 
 const ConstructorPrototypes = {
   graph: GraphProto,

src/text/index.js

@@ -2,6 +2,6 @@ import axioms from "./axioms.json";
 import folds from "./folds.json";
 
 export default {
-  axioms: JSON.parse(axioms),
-  folds: JSON.parse(folds),
+  axioms,
+  folds,
 };

tests/graph.clip.test.js

@@ -8,19 +8,19 @@ test("clip line", () => {
     edges_assignment: ["B", "B", "B", "B", "V"],
     faces_vertices: [[0, 1, 3], [2, 3, 1]],
   };
-  const segment0 = ear.graph.clip_line_in_boundary(graph, [1, 2], [0.5, 0.5]);
+  const segment0 = ear.graph.clip_line(graph, ear.line([1, 2], [0.5, 0.5]));
   expect(segment0[0][0]).toBe(0.25);
   expect(segment0[0][1]).toBe(0);
   expect(segment0[1][0]).toBe(0.75);
   expect(segment0[1][1]).toBe(1);
 
-  const segment1 = ear.graph.clip_line_in_boundary(graph, [1, 1], [0.5, 0.5]);
+  const segment1 = ear.graph.clip_line(graph, ear.line([1, 1], [0.5, 0.5]));
   expect(segment1[0][0]).toBe(0);
   expect(segment1[0][1]).toBe(0);
   expect(segment1[1][0]).toBe(1);
   expect(segment1[1][1]).toBe(1);
 
-  expect(ear.graph.clip_line_in_boundary(graph, [1, 0], [0, 1])).toBe(undefined);
+  expect(ear.graph.clip_line(graph, ear.line([1, 0], [0, 1]))).toBe(undefined);
 });
 
 test("clip line, edge collinear", () => {
@@ -31,11 +31,11 @@ test("clip line, edge collinear", () => {
     edges_assignment: ["B", "B", "B", "B", "V"],
     faces_vertices: [[0, 1, 3], [2, 3, 1]],
   };
-  // const top0 = ear.graph.clip_line_in_boundary(graph, [1, 0], [0, 1]);
-  // const top1 = ear.graph.clip_line_in_boundary(graph, [-1, 0], [0, 1]);
-  expect(ear.graph.clip_line_in_boundary(graph, [1, 0], [0, 0])).toBe(undefined);
-  expect(ear.graph.clip_line_in_boundary(graph, [-1, 0], [0, 0])).toBe(undefined);
-  expect(ear.graph.clip_line_in_boundary(graph, [0, 1], [0, 0])).toBe(undefined);
-  expect(ear.graph.clip_line_in_boundary(graph, [0, -1], [0, 0])).toBe(undefined);
-  expect(ear.graph.clip_line_in_boundary(graph, [1, 0], [0, 0])).toBe(undefined);
+  // const top0 = ear.graph.clip_line(graph, ear.line([1, 0], [0, 1]);
+  // const top1 = ear.graph.clip_line(graph, ear.line([-1, 0], [0, 1]);
+  expect(ear.graph.clip_line(graph, ear.line([1, 0], [0, 0]))).toBe(undefined);
+  expect(ear.graph.clip_line(graph, ear.line([-1, 0], [0, 0]))).toBe(undefined);
+  expect(ear.graph.clip_line(graph, ear.line([0, 1], [0, 0]))).toBe(undefined);
+  expect(ear.graph.clip_line(graph, ear.line([0, -1], [0, 0]))).toBe(undefined);
+  expect(ear.graph.clip_line(graph, ear.line([1, 0], [0, 0]))).toBe(undefined);
 });