2544730588

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/vanvalenlab/deepcell-label/commit/<a class=hub.com/vanvalenlab/deepcell-label/commit/f7d09204272dedcaeaee324f8c1fd7e0bfac528f">f7d092042<a href="https://github.com/vanvalenlab/deepcell-label/commit/f7d09204272dedcaeaee324f8c1fd7e0bfac528f">">Merge </a><a class="double-link" href="https://github.com/vanvalenlab/deepcell-label/commit/<a class="double-link" href="https://github.com/vanvalenlab/deepcell-label/commit/9a1683f9ccaa30e721f5bdc9eea33ac309045a7d">9a1683f9c</a>">9a1683f9c</a><a href="https://github.com/vanvalenlab/deepcell-label/commit/f7d09204272dedcaeaee324f8c1fd7e0bfac528f"> into ac5142104">ac5142104</a>

Pull Request Pull Request #334: Add forceLoadOutput URL parameter

Run Details

313 of 606 branches covered (51.65%)

Branch coverage included in aggregate %.

68 of 112 new or added lines in 30 files covered. (60.71%)

2332 of 3480 relevant lines covered (67.01%)

327.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.74

/visualizer/src/Project/service/labels/divisionsMachine.js

/** Manages division labels. */

import equal from 'fast-deep-equal';
import { assign, Machine, send } from 'xstate';
import { pure } from 'xstate/lib/actions';
import { fromEventBus } from '../eventBus';
import { combine } from './utils';

// TODO? spawn children for updating divisions (from changes in cells) vs. editing divisions (from user interactions)
// currently running in two parallel states (update and edit) in loaded

/** Replaces cell b with cell a in the divisions. */
function replace(divisions, a, b) {
  return (
    divisions
      .map((division) => {
        if (division.parent === b) {
          return { ...division, parent: a };
        }
        if (division.daughters.includes(b)) {
          const daughters = division.daughters
            .map((daughter) => (daughter === b ? a : daughter))
            // remove duplicate daughters
            .reduce((prev, curr) => (prev.includes(curr) ? prev : [...prev, curr]), []);
          return { ...division, daughters };
        }
        return division;
      })
      // remove divisions with same cell as parent and daughters
      .filter((division) => !division.daughters.includes(division.parent))
  );
}

/** Removes cell from the divisions. */
function remove(divisions, cell) {
  return divisions
    .map((d) => {
      const { parent, daughters } = d;
      if (parent === cell) {
        return { ...d, parent: null };
      }
      if (daughters.includes(cell)) {
        return { ...d, daughters: daughters.filter((daughter) => daughter !== cell) };
      }
      return d;
    })
    .filter((d) => d.parent !== null && d.daughters.length !== 0);
}

/** Swaps cells a and b in the divisions. */
function swap(divisions, a, b) {
  return (
    divisions
      .map((d) => {
        let { parent, daughters } = d;
        if (parent === a) {
          parent = b;
        } else if (parent === b) {
          parent = a;
        }
        daughters = daughters
          .map((daughter) => (daughter === a ? b : daughter === b ? a : daughter))
          // remove duplicate daughters
          .reduce((prev, curr) => (prev.includes(curr) ? prev : [...prev, curr]), []);

        return { ...d, parent, daughters };
      })
      // remove divisions with same cell as parent and daughters
      .filter((d) => !d.daughters.includes(d.parent))
  );
}

function updateFromCells(divisions, cells) {
  return (
    divisions
      .map((d) => {
        let { parent, daughters, t } = d;
        // check parent exists before division
        if (!cells.some((cell) => cell.cell === parent && cell.t < t)) {
          return { ...d, parent: null };
        }
        // check daughters exist after division
        daughters = daughters.filter((daughter) =>
          cells.some((cell) => cell.cell === daughter && cell.t >= t)
        );
        return { ...d, daughters };
      })
      // remove divisions with no parent or no daughters
      .filter((d) => d.parent !== null && d.daughters.length !== 0)
  );
}

function createDivisionsMachine({ eventBuses, undoRef }) {
  return Machine(
    {
      context: {
        divisions: [],
        undoRef,
        historyRef: null,
        edit: null,
      },
      entry: send('REGISTER_LABELS', { to: undoRef }),
      invoke: [
        { id: 'eventBus', src: fromEventBus('divisions', () => eventBuses.divisions) },
        { src: fromEventBus('divisions', () => eventBuses.load, 'LOADED') },
        { src: fromEventBus('divisions', () => eventBuses.cells) }, // listen for edit events (REPLACE, SWAP, REMOVE) and CELLS (generic updates)
      ],
      id: 'divisions',
      initial: 'loading',
      states: {
        loading: {
          type: 'parallel',
          states: {
            getDivisions: {
              initial: 'waiting',
              states: {
                waiting: {
                  on: {
                    LOADED: { actions: 'setDivisions', target: 'done' },
                  },
                },
                done: { type: 'final' },
              },
            },
            getHistoryRef: {
              initial: 'waiting',
              states: {
                waiting: {
                  on: {
                    LABEL_HISTORY: {
                      target: 'done',
                      actions: 'setHistoryRef',
                    },
                  },
                },
                done: { type: 'final' },
              },
            },
          },
          onDone: { target: 'loaded' },
        },
        loaded: {
          type: 'parallel',
          states: {
            edit: {
              initial: 'idle',
              states: {
                idle: {
                  entry: 'sendDivisions',
                  on: {
                    // from edit divisions machine
                    REMOVE_DAUGHTER: { actions: 'removeDaughter', target: 'editing' },
                    ADD_DAUGHTER: { actions: 'addDaughter', target: 'editing' },
                  },
                },
                editing: {
                  entry: 'setEditEvent',
                  type: 'parallel',
                  states: {
                    getEdit: {
                      entry: 'startEdit',
                      initial: 'idle',
                      states: {
                        idle: { on: { SAVE: { target: 'done', actions: 'setEdit' } } },
                        done: { type: 'final' },
                      },
                    },
                    getEdits: {
                      initial: 'editing',
                      states: {
                        editing: {
                          on: {
                            EDITED_DIVISIONS: { target: 'done', actions: 'setEditedDivisions' },
                          },
                        },
                        done: { type: 'final' },
                      },
                    },
                  },
                  onDone: {
                    target: 'idle',
                    actions: 'finishEditing',
                  },
                },
              },
            },
            update: {
              on: {
                // from CELLS event bus
                REPLACE: { actions: ['replace', 'sendDivisions'] },
                DELETE: { actions: ['delete', 'sendDivisions'] },
                SWAP: { actions: ['swap', 'sendDivisions'] },
                EDITED_CELLS: { actions: 'updateFromCells' },
                RESTORE: { actions: 'restore' },
              },
            },
          },
        },
      },
    },
    {
      actions: {
        setHistoryRef: assign({ historyRef: (_, __, meta) => meta._event.origin }),
        setDivisions: assign({ divisions: (ctx, evt) => evt.divisions }),
        setEditEvent: assign({ editEvent: (ctx, evt) => evt }),
        startEdit: send('SAVE', { to: (ctx) => ctx.undoRef }),
        setEdit: assign({ edit: (ctx, evt) => evt.edit }),
        setEditedDivisions: assign({ editedDivisions: (ctx, evt) => evt.divisions }),
        sendDivisions: send((ctx) => ({ type: 'DIVISIONS', divisions: ctx.divisions }), {
          to: 'eventBus',
        }),
        finishEditing: pure((ctx) => {
          return [
            assign({ divisions: (ctx) => ctx.editedDivisions }),
            send(
              {
                type: 'SNAPSHOT',
                before: { type: 'RESTORE', divisions: ctx.divisions },
                after: { type: 'RESTORE', divisions: ctx.editedDivisions },
                edit: ctx.edit,
              },
              { to: ctx.historyRef }
            ),
          ];
        }),
        addDaughter: send((ctx, evt) => {
          const index = ctx.divisions.findIndex((d) => d.parent === evt.parent);
          let divisions;
          if (index === -1) {
            divisions = [
              ...ctx.divisions,
              { parent: evt.parent, daughters: [evt.daughter], t: evt.t },
            ];
          } else {
            divisions = [...ctx.divisions];
            const division = divisions[index];
            divisions[index] = { ...division, daughters: [...division.daughters, evt.daughter] };
          }
          return { type: 'EDITED_DIVISIONS', divisions };
        }),
        removeDaughter: send((ctx, evt) => {
          const divisions = ctx.divisions
            .map((d) =>
              d.daughters.includes(evt.daughter)
                ? {
                    ...d,
                    daughters: d.daughters.filter((cell) => cell !== evt.daughter),
                  }
                : d
            )
            .filter((d) => d.daughters.length !== 0);
          return { type: 'EDITED_DIVISIONS', divisions };
        }),
        replace: pure((ctx, evt) => {
          let divisions = replace(ctx.divisions, evt.a, evt.b);
          divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);
          const before = { type: 'RESTORE', divisions: ctx.divisions };
          const after = { type: 'RESTORE', divisions: divisions };
          return [
            assign({ divisions }),
            send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
          ];
        }),
        delete: pure((ctx, evt) => {
          let divisions = remove(ctx.divisions, evt.cell);
          divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);
          const before = { type: 'RESTORE', divisions: ctx.divisions };
          const after = { type: 'RESTORE', divisions: divisions };
          return [
            assign({ divisions }),
            send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
          ];
        }),
        swap: pure((ctx, evt) => {
          let divisions = swap(ctx.divisions, evt.a, evt.b);
          divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);
          const before = { type: 'RESTORE', divisions: ctx.divisions };
          const after = { type: 'RESTORE', divisions: divisions };
          return [
            assign({ divisions }),
            send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
          ];
        }),
        updateFromCells: pure((ctx, evt) => {
          let divisions = updateFromCells(ctx.divisions, evt.cells);
          if (!equal(divisions, ctx.divisions)) {
            const before = { type: 'RESTORE', divisions: ctx.divisions };
            const after = { type: 'RESTORE', divisions: divisions };
            return [
              assign({ divisions }),
              send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
              send({ type: 'DIVISIONS', divisions }, { to: 'eventBus' }),
            ];
          }
          return [];
        }),
        restore: pure((ctx, evt) => {
          return [
            assign({ divisions: evt.divisions }),
            send({ type: 'DIVISIONS', divisions: evt.divisions }, { to: 'eventBus' }),
          ];
        }),
      },
    }
  );
}

export default createDivisionsMachine;

1	/** Manages division labels. */
2
3	import equal from 'fast-deep-equal';
4	import { assign, Machine, send } from 'xstate';
5	import { pure } from 'xstate/lib/actions';
6	import { fromEventBus } from '../eventBus';
7	import { combine } from './utils';
8
9	// TODO? spawn children for updating divisions (from changes in cells) vs. editing divisions (from user interactions)
10	// currently running in two parallel states (update and edit) in loaded
11
12	/** Replaces cell b with cell a in the divisions. */
13	function replace(divisions, a, b) {
14	return (	×
15	divisions
16	.map((division) => {
17	if (division.parent === b) {	×
18	return { ...division, parent: a };	×
19	}
20	if (division.daughters.includes(b)) {	×
21	const daughters = division.daughters	×
22	.map((daughter) => (daughter === b ? a : daughter))	×
23	// remove duplicate daughters
24	.reduce((prev, curr) => (prev.includes(curr) ? prev : [...prev, curr]), []);	×
25	return { ...division, daughters };	×
26	}
27	return division;	×
28	})
29	// remove divisions with same cell as parent and daughters
30	.filter((division) => !division.daughters.includes(division.parent))	×
31	);
32	}
33
34	/** Removes cell from the divisions. */
35	function remove(divisions, cell) {
36	return divisions	×
37	.map((d) => {
38	const { parent, daughters } = d;	×
39	if (parent === cell) {	×
40	return { ...d, parent: null };	×
41	}
42	if (daughters.includes(cell)) {	×
43	return { ...d, daughters: daughters.filter((daughter) => daughter !== cell) };	×
44	}
45	return d;	×
46	})
47	.filter((d) => d.parent !== null && d.daughters.length !== 0);	×
48	}
49
50	/** Swaps cells a and b in the divisions. */
51	function swap(divisions, a, b) {
52	return (	×
53	divisions
54	.map((d) => {
55	let { parent, daughters } = d;	×
56	if (parent === a) {	×
57	parent = b;	×
58	} else if (parent === b) {	×
59	parent = a;	×
60	}
61	daughters = daughters	×
62	.map((daughter) => (daughter === a ? b : daughter === b ? a : daughter))	×
63	// remove duplicate daughters
64	.reduce((prev, curr) => (prev.includes(curr) ? prev : [...prev, curr]), []);	×
65
66	return { ...d, parent, daughters };	×
67	})
68	// remove divisions with same cell as parent and daughters
69	.filter((d) => !d.daughters.includes(d.parent))	×
70	);
71	}
72
73	function updateFromCells(divisions, cells) {
74	return (	×
75	divisions
76	.map((d) => {
77	let { parent, daughters, t } = d;	×
78	// check parent exists before division
NEW 79	if (!cells.some((cell) => cell.cell === parent && cell.t < t)) {	×
80	return { ...d, parent: null };	×
81	}
82	// check daughters exist after division
83	daughters = daughters.filter((daughter) =>	×
NEW 84	cells.some((cell) => cell.cell === daughter && cell.t >= t)	×
85	);
86	return { ...d, daughters };	×
87	})
88	// remove divisions with no parent or no daughters
89	.filter((d) => d.parent !== null && d.daughters.length !== 0)	×
90	);
91	}
92
93	function createDivisionsMachine({ eventBuses, undoRef }) {
94	return Machine(	663✔
95	{
96	context: {
97	divisions: [],
98	undoRef,
99	historyRef: null,
100	edit: null,
101	},
102	entry: send('REGISTER_LABELS', { to: undoRef }),
103	invoke: [
104	{ id: 'eventBus', src: fromEventBus('divisions', () => eventBuses.divisions) },	23✔
105	{ src: fromEventBus('divisions', () => eventBuses.load, 'LOADED') },	23✔
106	{ src: fromEventBus('divisions', () => eventBuses.cells) }, // listen for edit events (REPLACE, SWAP, REMOVE) and CELLS (generic updates)	23✔
107	],
108	id: 'divisions',
109	initial: 'loading',
110	states: {
111	loading: {
112	type: 'parallel',
113	states: {
114	getDivisions: {
115	initial: 'waiting',
116	states: {
117	waiting: {
118	on: {
119	LOADED: { actions: 'setDivisions', target: 'done' },
120	},
121	},
122	done: { type: 'final' },
123	},
124	},
125	getHistoryRef: {
126	initial: 'waiting',
127	states: {
128	waiting: {
129	on: {
130	LABEL_HISTORY: {
131	target: 'done',
132	actions: 'setHistoryRef',
133	},
134	},
135	},
136	done: { type: 'final' },
137	},
138	},
139	},
140	onDone: { target: 'loaded' },
141	},
142	loaded: {
143	type: 'parallel',
144	states: {
145	edit: {
146	initial: 'idle',
147	states: {
148	idle: {
149	entry: 'sendDivisions',
150	on: {
151	// from edit divisions machine
152	REMOVE_DAUGHTER: { actions: 'removeDaughter', target: 'editing' },
153	ADD_DAUGHTER: { actions: 'addDaughter', target: 'editing' },
154	},
155	},
156	editing: {
157	entry: 'setEditEvent',
158	type: 'parallel',
159	states: {
160	getEdit: {
161	entry: 'startEdit',
162	initial: 'idle',
163	states: {
164	idle: { on: { SAVE: { target: 'done', actions: 'setEdit' } } },
165	done: { type: 'final' },
166	},
167	},
168	getEdits: {
169	initial: 'editing',
170	states: {
171	editing: {
172	on: {
173	EDITED_DIVISIONS: { target: 'done', actions: 'setEditedDivisions' },
174	},
175	},
176	done: { type: 'final' },
177	},
178	},
179	},
180	onDone: {
181	target: 'idle',
182	actions: 'finishEditing',
183	},
184	},
185	},
186	},
187	update: {
188	on: {
189	// from CELLS event bus
190	REPLACE: { actions: ['replace', 'sendDivisions'] },
191	DELETE: { actions: ['delete', 'sendDivisions'] },
192	SWAP: { actions: ['swap', 'sendDivisions'] },
193	EDITED_CELLS: { actions: 'updateFromCells' },
194	RESTORE: { actions: 'restore' },
195	},
196	},
197	},
198	},
199	},
200	},
201	{
202	actions: {
203	setHistoryRef: assign({ historyRef: (_, __, meta) => meta._event.origin }),	23✔
204	setDivisions: assign({ divisions: (ctx, evt) => evt.divisions }),	15✔
205	setEditEvent: assign({ editEvent: (ctx, evt) => evt }),	×
206	startEdit: send('SAVE', { to: (ctx) => ctx.undoRef }),	×
207	setEdit: assign({ edit: (ctx, evt) => evt.edit }),	×
208	setEditedDivisions: assign({ editedDivisions: (ctx, evt) => evt.divisions }),	×
209	sendDivisions: send((ctx) => ({ type: 'DIVISIONS', divisions: ctx.divisions }), {	15✔
210	to: 'eventBus',
211	}),
212	finishEditing: pure((ctx) => {
213	return [	×
214	assign({ divisions: (ctx) => ctx.editedDivisions }),	×
215	send(
216	{
217	type: 'SNAPSHOT',
218	before: { type: 'RESTORE', divisions: ctx.divisions },
219	after: { type: 'RESTORE', divisions: ctx.editedDivisions },
220	edit: ctx.edit,
221	},
222	{ to: ctx.historyRef }
223	),
224	];
225	}),
226	addDaughter: send((ctx, evt) => {
227	const index = ctx.divisions.findIndex((d) => d.parent === evt.parent);	×
228	let divisions;
229	if (index === -1) {	×
230	divisions = [	×
231	...ctx.divisions,
232	{ parent: evt.parent, daughters: [evt.daughter], t: evt.t },
233	];
234	} else {
235	divisions = [...ctx.divisions];	×
236	const division = divisions[index];	×
237	divisions[index] = { ...division, daughters: [...division.daughters, evt.daughter] };	×
238	}
239	return { type: 'EDITED_DIVISIONS', divisions };	×
240	}),
241	removeDaughter: send((ctx, evt) => {
242	const divisions = ctx.divisions	×
243	.map((d) =>
244	d.daughters.includes(evt.daughter)	×
245	? {
246	...d,
247	daughters: d.daughters.filter((cell) => cell !== evt.daughter),	×
248	}
249	: d
250	)
251	.filter((d) => d.daughters.length !== 0);	×
252	return { type: 'EDITED_DIVISIONS', divisions };	×
253	}),
254	replace: pure((ctx, evt) => {
255	let divisions = replace(ctx.divisions, evt.a, evt.b);	×
256	divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);	×
257	const before = { type: 'RESTORE', divisions: ctx.divisions };	×
258	const after = { type: 'RESTORE', divisions: divisions };	×
259	return [	×
260	assign({ divisions }),
261	send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
262	];
263	}),
264	delete: pure((ctx, evt) => {
265	let divisions = remove(ctx.divisions, evt.cell);	×
266	divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);	×
267	const before = { type: 'RESTORE', divisions: ctx.divisions };	×
268	const after = { type: 'RESTORE', divisions: divisions };	×
269	return [	×
270	assign({ divisions }),
271	send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
272	];
273	}),
274	swap: pure((ctx, evt) => {
275	let divisions = swap(ctx.divisions, evt.a, evt.b);	×
276	divisions = combine(ctx.divisions, divisions, evt.t, evt.mode);	×
277	const before = { type: 'RESTORE', divisions: ctx.divisions };	×
278	const after = { type: 'RESTORE', divisions: divisions };	×
279	return [	×
280	assign({ divisions }),
281	send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
282	];
283	}),
284	updateFromCells: pure((ctx, evt) => {
285	let divisions = updateFromCells(ctx.divisions, evt.cells);	×
286	if (!equal(divisions, ctx.divisions)) {	×
287	const before = { type: 'RESTORE', divisions: ctx.divisions };	×
288	const after = { type: 'RESTORE', divisions: divisions };	×
289	return [	×
290	assign({ divisions }),
291	send({ type: 'SNAPSHOT', edit: evt.edit, before, after }, { to: ctx.historyRef }),
292	send({ type: 'DIVISIONS', divisions }, { to: 'eventBus' }),
293	];
294	}
295	return [];	×
296	}),
297	restore: pure((ctx, evt) => {
298	return [	×
299	assign({ divisions: evt.divisions }),
300	send({ type: 'DIVISIONS', divisions: evt.divisions }, { to: 'eventBus' }),
301	];
302	}),
303	},
304	}
305	);
306	}
307
308	export default createDivisionsMachine;

vanvalenlab / deepcell-label / 2544730588

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous