128 lines
3.4 KiB
JavaScript
128 lines
3.4 KiB
JavaScript
|
|
const isNeighbor = function (itemA, itemB) {
|
|
let neighborA = itemA.neighbor,
|
|
neighborB = itemB.neighbor;
|
|
|
|
if (neighborA === undefined && neighborB === undefined) {
|
|
return false;
|
|
}
|
|
|
|
if (neighborA && neighborA.includes(itemB.id)) {
|
|
return true;
|
|
}
|
|
|
|
if (neighborB && neighborB.includes(itemA.id)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
SV.registerLayout('AdjoinMatrixGraph', {
|
|
sourcesPreprocess(sources) {
|
|
let dataLength = sources.length;
|
|
let matrixNodeLength = dataLength * dataLength;
|
|
let matrixNodes = [];
|
|
let i, j;
|
|
|
|
for (i = 0; i < matrixNodeLength; i++) {
|
|
matrixNodes.push({
|
|
id: `mn-${i}`,
|
|
type: 'matrixNode',
|
|
indexTop: i < dataLength ? sources[i].id : undefined,
|
|
indexLeft: i % dataLength === 0? sources[i / dataLength].id : undefined,
|
|
data: 0
|
|
});
|
|
}
|
|
|
|
for (i = 0; i < dataLength; i++) {
|
|
for (j = 0; j < dataLength; j++) {
|
|
let itemI = sources[i],
|
|
itemJ = sources[j];
|
|
|
|
if (itemI.id !== itemJ.id && isNeighbor(itemI, itemJ)) {
|
|
matrixNodes[i * dataLength + j].data = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
sources.push(...matrixNodes);
|
|
|
|
return sources;
|
|
},
|
|
|
|
defineOptions() {
|
|
return {
|
|
element: {
|
|
default: {
|
|
type: 'circle',
|
|
label: '[id]',
|
|
size: 40,
|
|
style: {
|
|
stroke: '#333',
|
|
fill: '#95e1d3'
|
|
}
|
|
},
|
|
matrixNode: {
|
|
type: 'indexed-node',
|
|
label: '[data]',
|
|
size: [40, 40],
|
|
style: {
|
|
stroke: '#333',
|
|
fill: '#95e1d3'
|
|
},
|
|
indexOptions: {
|
|
indexTop: { position: 'top' },
|
|
indexLeft: { position: 'left' }
|
|
}
|
|
}
|
|
},
|
|
link: {
|
|
neighbor: {
|
|
style: {
|
|
stroke: '#333'
|
|
}
|
|
}
|
|
},
|
|
layout: {
|
|
radius: 150,
|
|
interval: 250
|
|
},
|
|
behavior: {
|
|
dragNode: ['default']
|
|
}
|
|
};
|
|
},
|
|
|
|
layout(elements, layoutOptions) {
|
|
let nodes = elements.filter(item => item.type === 'default'),
|
|
matrixNodes = elements.filter(item => item.type === 'matrixNode'),
|
|
nodeLength = nodes.length,
|
|
matrixNodeLength = matrixNodes.length,
|
|
{ interval, radius } = layoutOptions,
|
|
intervalAngle = 2 * Math.PI / nodes.length,
|
|
matrixNodeSize = matrixNodes[0].get('size')[0],
|
|
i;
|
|
|
|
const matrixY = -radius,
|
|
matrixX = interval;
|
|
|
|
for (i = 0; i < nodeLength; i++) {
|
|
let [x, y] = Vector.rotation(-intervalAngle * i, [0, -radius]);
|
|
|
|
nodes[i].set({ x, y });
|
|
}
|
|
|
|
for (i = 0; i < matrixNodeLength; i++) {
|
|
let x = matrixX + (i % nodeLength) * matrixNodeSize;
|
|
y = matrixY + Math.floor(i / nodeLength) * matrixNodeSize;
|
|
|
|
matrixNodes[i].set({ x, y });
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
|