(function webpackUniversalModuleDefinition(root, factory) { if(typeof exports === 'object' && typeof module === 'object') module.exports = factory(require("layout-base")); else if(typeof define === 'function' && define.amd) define(["layout-base"], factory); else if(typeof exports === 'object') exports["coseBase"] = factory(require("layout-base")); else root["coseBase"] = factory(root["layoutBase"]); })(this, function(__WEBPACK_EXTERNAL_MODULE_0__) { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules[moduleId]) { /******/ return installedModules[moduleId].exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules[moduleId] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (__webpack_modules__) /******/ __webpack_require__.m = modules; /******/ /******/ // expose the module cache /******/ __webpack_require__.c = installedModules; /******/ /******/ // identity function for calling harmony imports with the correct context /******/ __webpack_require__.i = function(value) { return value; }; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { /******/ configurable: false, /******/ enumerable: true, /******/ get: getter /******/ }); /******/ } /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module['default']; } : /******/ function getModuleExports() { return module; }; /******/ __webpack_require__.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(__webpack_require__.s = 7); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports) { module.exports = __WEBPACK_EXTERNAL_MODULE_0__; /***/ }), /* 1 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var FDLayoutConstants = __webpack_require__(0).FDLayoutConstants; function CoSEConstants() {} //CoSEConstants inherits static props in FDLayoutConstants for (var prop in FDLayoutConstants) { CoSEConstants[prop] = FDLayoutConstants[prop]; } CoSEConstants.DEFAULT_USE_MULTI_LEVEL_SCALING = false; CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH; CoSEConstants.DEFAULT_COMPONENT_SEPERATION = 60; CoSEConstants.TILE = true; CoSEConstants.TILING_PADDING_VERTICAL = 10; CoSEConstants.TILING_PADDING_HORIZONTAL = 10; CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = false; // make this true when cose is used incrementally as a part of other non-incremental layout module.exports = CoSEConstants; /***/ }), /* 2 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var FDLayoutEdge = __webpack_require__(0).FDLayoutEdge; function CoSEEdge(source, target, vEdge) { FDLayoutEdge.call(this, source, target, vEdge); } CoSEEdge.prototype = Object.create(FDLayoutEdge.prototype); for (var prop in FDLayoutEdge) { CoSEEdge[prop] = FDLayoutEdge[prop]; } module.exports = CoSEEdge; /***/ }), /* 3 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var LGraph = __webpack_require__(0).LGraph; function CoSEGraph(parent, graphMgr, vGraph) { LGraph.call(this, parent, graphMgr, vGraph); } CoSEGraph.prototype = Object.create(LGraph.prototype); for (var prop in LGraph) { CoSEGraph[prop] = LGraph[prop]; } module.exports = CoSEGraph; /***/ }), /* 4 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var LGraphManager = __webpack_require__(0).LGraphManager; function CoSEGraphManager(layout) { LGraphManager.call(this, layout); } CoSEGraphManager.prototype = Object.create(LGraphManager.prototype); for (var prop in LGraphManager) { CoSEGraphManager[prop] = LGraphManager[prop]; } module.exports = CoSEGraphManager; /***/ }), /* 5 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var FDLayoutNode = __webpack_require__(0).FDLayoutNode; var IMath = __webpack_require__(0).IMath; function CoSENode(gm, loc, size, vNode) { FDLayoutNode.call(this, gm, loc, size, vNode); } CoSENode.prototype = Object.create(FDLayoutNode.prototype); for (var prop in FDLayoutNode) { CoSENode[prop] = FDLayoutNode[prop]; } CoSENode.prototype.move = function () { var layout = this.graphManager.getLayout(); this.displacementX = layout.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren; this.displacementY = layout.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren; if (Math.abs(this.displacementX) > layout.coolingFactor * layout.maxNodeDisplacement) { this.displacementX = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementX); } if (Math.abs(this.displacementY) > layout.coolingFactor * layout.maxNodeDisplacement) { this.displacementY = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementY); } // a simple node, just move it if (this.child == null) { this.moveBy(this.displacementX, this.displacementY); } // an empty compound node, again just move it else if (this.child.getNodes().length == 0) { this.moveBy(this.displacementX, this.displacementY); } // non-empty compound node, propogate movement to children as well else { this.propogateDisplacementToChildren(this.displacementX, this.displacementY); } layout.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY); this.springForceX = 0; this.springForceY = 0; this.repulsionForceX = 0; this.repulsionForceY = 0; this.gravitationForceX = 0; this.gravitationForceY = 0; this.displacementX = 0; this.displacementY = 0; }; CoSENode.prototype.propogateDisplacementToChildren = function (dX, dY) { var nodes = this.getChild().getNodes(); var node; for (var i = 0; i < nodes.length; i++) { node = nodes[i]; if (node.getChild() == null) { node.moveBy(dX, dY); node.displacementX += dX; node.displacementY += dY; } else { node.propogateDisplacementToChildren(dX, dY); } } }; CoSENode.prototype.setPred1 = function (pred1) { this.pred1 = pred1; }; CoSENode.prototype.getPred1 = function () { return pred1; }; CoSENode.prototype.getPred2 = function () { return pred2; }; CoSENode.prototype.setNext = function (next) { this.next = next; }; CoSENode.prototype.getNext = function () { return next; }; CoSENode.prototype.setProcessed = function (processed) { this.processed = processed; }; CoSENode.prototype.isProcessed = function () { return processed; }; module.exports = CoSENode; /***/ }), /* 6 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var FDLayout = __webpack_require__(0).FDLayout; var CoSEGraphManager = __webpack_require__(4); var CoSEGraph = __webpack_require__(3); var CoSENode = __webpack_require__(5); var CoSEEdge = __webpack_require__(2); var CoSEConstants = __webpack_require__(1); var FDLayoutConstants = __webpack_require__(0).FDLayoutConstants; var LayoutConstants = __webpack_require__(0).LayoutConstants; var Point = __webpack_require__(0).Point; var PointD = __webpack_require__(0).PointD; var Layout = __webpack_require__(0).Layout; var Integer = __webpack_require__(0).Integer; var IGeometry = __webpack_require__(0).IGeometry; var LGraph = __webpack_require__(0).LGraph; var Transform = __webpack_require__(0).Transform; function CoSELayout() { FDLayout.call(this); this.toBeTiled = {}; // Memorize if a node is to be tiled or is tiled } CoSELayout.prototype = Object.create(FDLayout.prototype); for (var prop in FDLayout) { CoSELayout[prop] = FDLayout[prop]; } CoSELayout.prototype.newGraphManager = function () { var gm = new CoSEGraphManager(this); this.graphManager = gm; return gm; }; CoSELayout.prototype.newGraph = function (vGraph) { return new CoSEGraph(null, this.graphManager, vGraph); }; CoSELayout.prototype.newNode = function (vNode) { return new CoSENode(this.graphManager, vNode); }; CoSELayout.prototype.newEdge = function (vEdge) { return new CoSEEdge(null, null, vEdge); }; CoSELayout.prototype.initParameters = function () { FDLayout.prototype.initParameters.call(this, arguments); if (!this.isSubLayout) { if (CoSEConstants.DEFAULT_EDGE_LENGTH < 10) { this.idealEdgeLength = 10; } else { this.idealEdgeLength = CoSEConstants.DEFAULT_EDGE_LENGTH; } this.useSmartIdealEdgeLengthCalculation = CoSEConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION; this.springConstant = FDLayoutConstants.DEFAULT_SPRING_STRENGTH; this.repulsionConstant = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH; this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH; this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH; this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR; this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR; // variables for tree reduction support this.prunedNodesAll = []; this.growTreeIterations = 0; this.afterGrowthIterations = 0; this.isTreeGrowing = false; this.isGrowthFinished = false; // variables for cooling this.coolingCycle = 0; this.maxCoolingCycle = this.maxIterations / FDLayoutConstants.CONVERGENCE_CHECK_PERIOD; this.finalTemperature = FDLayoutConstants.CONVERGENCE_CHECK_PERIOD / this.maxIterations; this.coolingAdjuster = 1; } }; CoSELayout.prototype.layout = function () { var createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED; if (createBendsAsNeeded) { this.createBendpoints(); this.graphManager.resetAllEdges(); } this.level = 0; return this.classicLayout(); }; CoSELayout.prototype.classicLayout = function () { this.nodesWithGravity = this.calculateNodesToApplyGravitationTo(); this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity); this.calcNoOfChildrenForAllNodes(); this.graphManager.calcLowestCommonAncestors(); this.graphManager.calcInclusionTreeDepths(); this.graphManager.getRoot().calcEstimatedSize(); this.calcIdealEdgeLengths(); if (!this.incremental) { var forest = this.getFlatForest(); // The graph associated with this layout is flat and a forest if (forest.length > 0) { this.positionNodesRadially(forest); } // The graph associated with this layout is not flat or a forest else { // Reduce the trees when incremental mode is not enabled and graph is not a forest this.reduceTrees(); // Update nodes that gravity will be applied this.graphManager.resetAllNodesToApplyGravitation(); var allNodes = new Set(this.getAllNodes()); var intersection = this.nodesWithGravity.filter(function (x) { return allNodes.has(x); }); this.graphManager.setAllNodesToApplyGravitation(intersection); this.positionNodesRandomly(); } } else { if (CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL) { // Reduce the trees in incremental mode if only this constant is set to true this.reduceTrees(); // Update nodes that gravity will be applied this.graphManager.resetAllNodesToApplyGravitation(); var allNodes = new Set(this.getAllNodes()); var intersection = this.nodesWithGravity.filter(function (x) { return allNodes.has(x); }); this.graphManager.setAllNodesToApplyGravitation(intersection); } } this.initSpringEmbedder(); this.runSpringEmbedder(); return true; }; CoSELayout.prototype.tick = function () { this.totalIterations++; if (this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) { if (this.prunedNodesAll.length > 0) { this.isTreeGrowing = true; } else { return true; } } if (this.totalIterations % FDLayoutConstants.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) { if (this.isConverged()) { if (this.prunedNodesAll.length > 0) { this.isTreeGrowing = true; } else { return true; } } this.coolingCycle++; if (this.layoutQuality == 0) { // quality - "draft" this.coolingAdjuster = this.coolingCycle; } else if (this.layoutQuality == 1) { // quality - "default" this.coolingAdjuster = this.coolingCycle / 3; } // cooling schedule is based on http://www.btluke.com/simanf1.html -> cooling schedule 3 this.coolingFactor = Math.max(this.initialCoolingFactor - Math.pow(this.coolingCycle, Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature); this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor)); } // Operations while tree is growing again if (this.isTreeGrowing) { if (this.growTreeIterations % 10 == 0) { if (this.prunedNodesAll.length > 0) { this.graphManager.updateBounds(); this.updateGrid(); this.growTree(this.prunedNodesAll); // Update nodes that gravity will be applied this.graphManager.resetAllNodesToApplyGravitation(); var allNodes = new Set(this.getAllNodes()); var intersection = this.nodesWithGravity.filter(function (x) { return allNodes.has(x); }); this.graphManager.setAllNodesToApplyGravitation(intersection); this.graphManager.updateBounds(); this.updateGrid(); this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL; } else { this.isTreeGrowing = false; this.isGrowthFinished = true; } } this.growTreeIterations++; } // Operations after growth is finished if (this.isGrowthFinished) { if (this.isConverged()) { return true; } if (this.afterGrowthIterations % 10 == 0) { this.graphManager.updateBounds(); this.updateGrid(); } this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100); this.afterGrowthIterations++; } var gridUpdateAllowed = !this.isTreeGrowing && !this.isGrowthFinished; var forceToNodeSurroundingUpdate = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished; this.totalDisplacement = 0; this.graphManager.updateBounds(); this.calcSpringForces(); this.calcRepulsionForces(gridUpdateAllowed, forceToNodeSurroundingUpdate); this.calcGravitationalForces(); this.moveNodes(); this.animate(); return false; // Layout is not ended yet return false }; CoSELayout.prototype.getPositionsData = function () { var allNodes = this.graphManager.getAllNodes(); var pData = {}; for (var i = 0; i < allNodes.length; i++) { var rect = allNodes[i].rect; var id = allNodes[i].id; pData[id] = { id: id, x: rect.getCenterX(), y: rect.getCenterY(), w: rect.width, h: rect.height }; } return pData; }; CoSELayout.prototype.runSpringEmbedder = function () { this.initialAnimationPeriod = 25; this.animationPeriod = this.initialAnimationPeriod; var layoutEnded = false; // If aminate option is 'during' signal that layout is supposed to start iterating if (FDLayoutConstants.ANIMATE === 'during') { this.emit('layoutstarted'); } else { // If aminate option is 'during' tick() function will be called on index.js while (!layoutEnded) { layoutEnded = this.tick(); } this.graphManager.updateBounds(); } }; CoSELayout.prototype.calculateNodesToApplyGravitationTo = function () { var nodeList = []; var graph; var graphs = this.graphManager.getGraphs(); var size = graphs.length; var i; for (i = 0; i < size; i++) { graph = graphs[i]; graph.updateConnected(); if (!graph.isConnected) { nodeList = nodeList.concat(graph.getNodes()); } } return nodeList; }; CoSELayout.prototype.createBendpoints = function () { var edges = []; edges = edges.concat(this.graphManager.getAllEdges()); var visited = new Set(); var i; for (i = 0; i < edges.length; i++) { var edge = edges[i]; if (!visited.has(edge)) { var source = edge.getSource(); var target = edge.getTarget(); if (source == target) { edge.getBendpoints().push(new PointD()); edge.getBendpoints().push(new PointD()); this.createDummyNodesForBendpoints(edge); visited.add(edge); } else { var edgeList = []; edgeList = edgeList.concat(source.getEdgeListToNode(target)); edgeList = edgeList.concat(target.getEdgeListToNode(source)); if (!visited.has(edgeList[0])) { if (edgeList.length > 1) { var k; for (k = 0; k < edgeList.length; k++) { var multiEdge = edgeList[k]; multiEdge.getBendpoints().push(new PointD()); this.createDummyNodesForBendpoints(multiEdge); } } edgeList.forEach(function (edge) { visited.add(edge); }); } } } if (visited.size == edges.length) { break; } } }; CoSELayout.prototype.positionNodesRadially = function (forest) { // We tile the trees to a grid row by row; first tree starts at (0,0) var currentStartingPoint = new Point(0, 0); var numberOfColumns = Math.ceil(Math.sqrt(forest.length)); var height = 0; var currentY = 0; var currentX = 0; var point = new PointD(0, 0); for (var i = 0; i < forest.length; i++) { if (i % numberOfColumns == 0) { // Start of a new row, make the x coordinate 0, increment the // y coordinate with the max height of the previous row currentX = 0; currentY = height; if (i != 0) { currentY += CoSEConstants.DEFAULT_COMPONENT_SEPERATION; } height = 0; } var tree = forest[i]; // Find the center of the tree var centerNode = Layout.findCenterOfTree(tree); // Set the staring point of the next tree currentStartingPoint.x = currentX; currentStartingPoint.y = currentY; // Do a radial layout starting with the center point = CoSELayout.radialLayout(tree, centerNode, currentStartingPoint); if (point.y > height) { height = Math.floor(point.y); } currentX = Math.floor(point.x + CoSEConstants.DEFAULT_COMPONENT_SEPERATION); } this.transform(new PointD(LayoutConstants.WORLD_CENTER_X - point.x / 2, LayoutConstants.WORLD_CENTER_Y - point.y / 2)); }; CoSELayout.radialLayout = function (tree, centerNode, startingPoint) { var radialSep = Math.max(this.maxDiagonalInTree(tree), CoSEConstants.DEFAULT_RADIAL_SEPARATION); CoSELayout.branchRadialLayout(centerNode, null, 0, 359, 0, radialSep); var bounds = LGraph.calculateBounds(tree); var transform = new Transform(); transform.setDeviceOrgX(bounds.getMinX()); transform.setDeviceOrgY(bounds.getMinY()); transform.setWorldOrgX(startingPoint.x); transform.setWorldOrgY(startingPoint.y); for (var i = 0; i < tree.length; i++) { var node = tree[i]; node.transform(transform); } var bottomRight = new PointD(bounds.getMaxX(), bounds.getMaxY()); return transform.inverseTransformPoint(bottomRight); }; CoSELayout.branchRadialLayout = function (node, parentOfNode, startAngle, endAngle, distance, radialSeparation) { // First, position this node by finding its angle. var halfInterval = (endAngle - startAngle + 1) / 2; if (halfInterval < 0) { halfInterval += 180; } var nodeAngle = (halfInterval + startAngle) % 360; var teta = nodeAngle * IGeometry.TWO_PI / 360; // Make polar to java cordinate conversion. var cos_teta = Math.cos(teta); var x_ = distance * Math.cos(teta); var y_ = distance * Math.sin(teta); node.setCenter(x_, y_); // Traverse all neighbors of this node and recursively call this // function. var neighborEdges = []; neighborEdges = neighborEdges.concat(node.getEdges()); var childCount = neighborEdges.length; if (parentOfNode != null) { childCount--; } var branchCount = 0; var incEdgesCount = neighborEdges.length; var startIndex; var edges = node.getEdgesBetween(parentOfNode); // If there are multiple edges, prune them until there remains only one // edge. while (edges.length > 1) { //neighborEdges.remove(edges.remove(0)); var temp = edges[0]; edges.splice(0, 1); var index = neighborEdges.indexOf(temp); if (index >= 0) { neighborEdges.splice(index, 1); } incEdgesCount--; childCount--; } if (parentOfNode != null) { //assert edges.length == 1; startIndex = (neighborEdges.indexOf(edges[0]) + 1) % incEdgesCount; } else { startIndex = 0; } var stepAngle = Math.abs(endAngle - startAngle) / childCount; for (var i = startIndex; branchCount != childCount; i = ++i % incEdgesCount) { var currentNeighbor = neighborEdges[i].getOtherEnd(node); // Don't back traverse to root node in current tree. if (currentNeighbor == parentOfNode) { continue; } var childStartAngle = (startAngle + branchCount * stepAngle) % 360; var childEndAngle = (childStartAngle + stepAngle) % 360; CoSELayout.branchRadialLayout(currentNeighbor, node, childStartAngle, childEndAngle, distance + radialSeparation, radialSeparation); branchCount++; } }; CoSELayout.maxDiagonalInTree = function (tree) { var maxDiagonal = Integer.MIN_VALUE; for (var i = 0; i < tree.length; i++) { var node = tree[i]; var diagonal = node.getDiagonal(); if (diagonal > maxDiagonal) { maxDiagonal = diagonal; } } return maxDiagonal; }; CoSELayout.prototype.calcRepulsionRange = function () { // formula is 2 x (level + 1) x idealEdgeLength return 2 * (this.level + 1) * this.idealEdgeLength; }; // Tiling methods // Group zero degree members whose parents are not to be tiled, create dummy parents where needed and fill memberGroups by their dummp parent id's CoSELayout.prototype.groupZeroDegreeMembers = function () { var self = this; // array of [parent_id x oneDegreeNode_id] var tempMemberGroups = {}; // A temporary map of parent node and its zero degree members this.memberGroups = {}; // A map of dummy parent node and its zero degree members whose parents are not to be tiled this.idToDummyNode = {}; // A map of id to dummy node var zeroDegree = []; // List of zero degree nodes whose parents are not to be tiled var allNodes = this.graphManager.getAllNodes(); // Fill zero degree list for (var i = 0; i < allNodes.length; i++) { var node = allNodes[i]; var parent = node.getParent(); // If a node has zero degree and its parent is not to be tiled if exists add that node to zeroDegres list if (this.getNodeDegreeWithChildren(node) === 0 && (parent.id == undefined || !this.getToBeTiled(parent))) { zeroDegree.push(node); } } // Create a map of parent node and its zero degree members for (var i = 0; i < zeroDegree.length; i++) { var node = zeroDegree[i]; // Zero degree node itself var p_id = node.getParent().id; // Parent id if (typeof tempMemberGroups[p_id] === "undefined") tempMemberGroups[p_id] = []; tempMemberGroups[p_id] = tempMemberGroups[p_id].concat(node); // Push node to the list belongs to its parent in tempMemberGroups } // If there are at least two nodes at a level, create a dummy compound for them Object.keys(tempMemberGroups).forEach(function (p_id) { if (tempMemberGroups[p_id].length > 1) { var dummyCompoundId = "DummyCompound_" + p_id; // The id of dummy compound which will be created soon self.memberGroups[dummyCompoundId] = tempMemberGroups[p_id]; // Add dummy compound to memberGroups var parent = tempMemberGroups[p_id][0].getParent(); // The parent of zero degree nodes will be the parent of new dummy compound // Create a dummy compound with calculated id var dummyCompound = new CoSENode(self.graphManager); dummyCompound.id = dummyCompoundId; dummyCompound.paddingLeft = parent.paddingLeft || 0; dummyCompound.paddingRight = parent.paddingRight || 0; dummyCompound.paddingBottom = parent.paddingBottom || 0; dummyCompound.paddingTop = parent.paddingTop || 0; self.idToDummyNode[dummyCompoundId] = dummyCompound; var dummyParentGraph = self.getGraphManager().add(self.newGraph(), dummyCompound); var parentGraph = parent.getChild(); // Add dummy compound to parent the graph parentGraph.add(dummyCompound); // For each zero degree node in this level remove it from its parent graph and add it to the graph of dummy parent for (var i = 0; i < tempMemberGroups[p_id].length; i++) { var node = tempMemberGroups[p_id][i]; parentGraph.remove(node); dummyParentGraph.add(node); } } }); }; CoSELayout.prototype.clearCompounds = function () { var childGraphMap = {}; var idToNode = {}; // Get compound ordering by finding the inner one first this.performDFSOnCompounds(); for (var i = 0; i < this.compoundOrder.length; i++) { idToNode[this.compoundOrder[i].id] = this.compoundOrder[i]; childGraphMap[this.compoundOrder[i].id] = [].concat(this.compoundOrder[i].getChild().getNodes()); // Remove children of compounds this.graphManager.remove(this.compoundOrder[i].getChild()); this.compoundOrder[i].child = null; } this.graphManager.resetAllNodes(); // Tile the removed children this.tileCompoundMembers(childGraphMap, idToNode); }; CoSELayout.prototype.clearZeroDegreeMembers = function () { var self = this; var tiledZeroDegreePack = this.tiledZeroDegreePack = []; Object.keys(this.memberGroups).forEach(function (id) { var compoundNode = self.idToDummyNode[id]; // Get the dummy compound tiledZeroDegreePack[id] = self.tileNodes(self.memberGroups[id], compoundNode.paddingLeft + compoundNode.paddingRight); // Set the width and height of the dummy compound as calculated compoundNode.rect.width = tiledZeroDegreePack[id].width; compoundNode.rect.height = tiledZeroDegreePack[id].height; }); }; CoSELayout.prototype.repopulateCompounds = function () { for (var i = this.compoundOrder.length - 1; i >= 0; i--) { var lCompoundNode = this.compoundOrder[i]; var id = lCompoundNode.id; var horizontalMargin = lCompoundNode.paddingLeft; var verticalMargin = lCompoundNode.paddingTop; this.adjustLocations(this.tiledMemberPack[id], lCompoundNode.rect.x, lCompoundNode.rect.y, horizontalMargin, verticalMargin); } }; CoSELayout.prototype.repopulateZeroDegreeMembers = function () { var self = this; var tiledPack = this.tiledZeroDegreePack; Object.keys(tiledPack).forEach(function (id) { var compoundNode = self.idToDummyNode[id]; // Get the dummy compound by its id var horizontalMargin = compoundNode.paddingLeft; var verticalMargin = compoundNode.paddingTop; // Adjust the positions of nodes wrt its compound self.adjustLocations(tiledPack[id], compoundNode.rect.x, compoundNode.rect.y, horizontalMargin, verticalMargin); }); }; CoSELayout.prototype.getToBeTiled = function (node) { var id = node.id; //firstly check the previous results if (this.toBeTiled[id] != null) { return this.toBeTiled[id]; } //only compound nodes are to be tiled var childGraph = node.getChild(); if (childGraph == null) { this.toBeTiled[id] = false; return false; } var children = childGraph.getNodes(); // Get the children nodes //a compound node is not to be tiled if all of its compound children are not to be tiled for (var i = 0; i < children.length; i++) { var theChild = children[i]; if (this.getNodeDegree(theChild) > 0) { this.toBeTiled[id] = false; return false; } //pass the children not having the compound structure if (theChild.getChild() == null) { this.toBeTiled[theChild.id] = false; continue; } if (!this.getToBeTiled(theChild)) { this.toBeTiled[id] = false; return false; } } this.toBeTiled[id] = true; return true; }; // Get degree of a node depending of its edges and independent of its children CoSELayout.prototype.getNodeDegree = function (node) { var id = node.id; var edges = node.getEdges(); var degree = 0; // For the edges connected for (var i = 0; i < edges.length; i++) { var edge = edges[i]; if (edge.getSource().id !== edge.getTarget().id) { degree = degree + 1; } } return degree; }; // Get degree of a node with its children CoSELayout.prototype.getNodeDegreeWithChildren = function (node) { var degree = this.getNodeDegree(node); if (node.getChild() == null) { return degree; } var children = node.getChild().getNodes(); for (var i = 0; i < children.length; i++) { var child = children[i]; degree += this.getNodeDegreeWithChildren(child); } return degree; }; CoSELayout.prototype.performDFSOnCompounds = function () { this.compoundOrder = []; this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes()); }; CoSELayout.prototype.fillCompexOrderByDFS = function (children) { for (var i = 0; i < children.length; i++) { var child = children[i]; if (child.getChild() != null) { this.fillCompexOrderByDFS(child.getChild().getNodes()); } if (this.getToBeTiled(child)) { this.compoundOrder.push(child); } } }; /** * This method places each zero degree member wrt given (x,y) coordinates (top left). */ CoSELayout.prototype.adjustLocations = function (organization, x, y, compoundHorizontalMargin, compoundVerticalMargin) { x += compoundHorizontalMargin; y += compoundVerticalMargin; var left = x; for (var i = 0; i < organization.rows.length; i++) { var row = organization.rows[i]; x = left; var maxHeight = 0; for (var j = 0; j < row.length; j++) { var lnode = row[j]; lnode.rect.x = x; // + lnode.rect.width / 2; lnode.rect.y = y; // + lnode.rect.height / 2; x += lnode.rect.width + organization.horizontalPadding; if (lnode.rect.height > maxHeight) maxHeight = lnode.rect.height; } y += maxHeight + organization.verticalPadding; } }; CoSELayout.prototype.tileCompoundMembers = function (childGraphMap, idToNode) { var self = this; this.tiledMemberPack = []; Object.keys(childGraphMap).forEach(function (id) { // Get the compound node var compoundNode = idToNode[id]; self.tiledMemberPack[id] = self.tileNodes(childGraphMap[id], compoundNode.paddingLeft + compoundNode.paddingRight); compoundNode.rect.width = self.tiledMemberPack[id].width; compoundNode.rect.height = self.tiledMemberPack[id].height; }); }; CoSELayout.prototype.tileNodes = function (nodes, minWidth) { var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL; var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL; var organization = { rows: [], rowWidth: [], rowHeight: [], width: 0, height: minWidth, // assume minHeight equals to minWidth verticalPadding: verticalPadding, horizontalPadding: horizontalPadding }; // Sort the nodes in ascending order of their areas nodes.sort(function (n1, n2) { if (n1.rect.width * n1.rect.height > n2.rect.width * n2.rect.height) return -1; if (n1.rect.width * n1.rect.height < n2.rect.width * n2.rect.height) return 1; return 0; }); // Create the organization -> tile members for (var i = 0; i < nodes.length; i++) { var lNode = nodes[i]; if (organization.rows.length == 0) { this.insertNodeToRow(organization, lNode, 0, minWidth); } else if (this.canAddHorizontal(organization, lNode.rect.width, lNode.rect.height)) { this.insertNodeToRow(organization, lNode, this.getShortestRowIndex(organization), minWidth); } else { this.insertNodeToRow(organization, lNode, organization.rows.length, minWidth); } this.shiftToLastRow(organization); } return organization; }; CoSELayout.prototype.insertNodeToRow = function (organization, node, rowIndex, minWidth) { var minCompoundSize = minWidth; // Add new row if needed if (rowIndex == organization.rows.length) { var secondDimension = []; organization.rows.push(secondDimension); organization.rowWidth.push(minCompoundSize); organization.rowHeight.push(0); } // Update row width var w = organization.rowWidth[rowIndex] + node.rect.width; if (organization.rows[rowIndex].length > 0) { w += organization.horizontalPadding; } organization.rowWidth[rowIndex] = w; // Update compound width if (organization.width < w) { organization.width = w; } // Update height var h = node.rect.height; if (rowIndex > 0) h += organization.verticalPadding; var extraHeight = 0; if (h > organization.rowHeight[rowIndex]) { extraHeight = organization.rowHeight[rowIndex]; organization.rowHeight[rowIndex] = h; extraHeight = organization.rowHeight[rowIndex] - extraHeight; } organization.height += extraHeight; // Insert node organization.rows[rowIndex].push(node); }; //Scans the rows of an organization and returns the one with the min width CoSELayout.prototype.getShortestRowIndex = function (organization) { var r = -1; var min = Number.MAX_VALUE; for (var i = 0; i < organization.rows.length; i++) { if (organization.rowWidth[i] < min) { r = i; min = organization.rowWidth[i]; } } return r; }; //Scans the rows of an organization and returns the one with the max width CoSELayout.prototype.getLongestRowIndex = function (organization) { var r = -1; var max = Number.MIN_VALUE; for (var i = 0; i < organization.rows.length; i++) { if (organization.rowWidth[i] > max) { r = i; max = organization.rowWidth[i]; } } return r; }; /** * This method checks whether adding extra width to the organization violates * the aspect ratio(1) or not. */ CoSELayout.prototype.canAddHorizontal = function (organization, extraWidth, extraHeight) { var sri = this.getShortestRowIndex(organization); if (sri < 0) { return true; } var min = organization.rowWidth[sri]; if (min + organization.horizontalPadding + extraWidth <= organization.width) return true; var hDiff = 0; // Adding to an existing row if (organization.rowHeight[sri] < extraHeight) { if (sri > 0) hDiff = extraHeight + organization.verticalPadding - organization.rowHeight[sri]; } var add_to_row_ratio; if (organization.width - min >= extraWidth + organization.horizontalPadding) { add_to_row_ratio = (organization.height + hDiff) / (min + extraWidth + organization.horizontalPadding); } else { add_to_row_ratio = (organization.height + hDiff) / organization.width; } // Adding a new row for this node hDiff = extraHeight + organization.verticalPadding; var add_new_row_ratio; if (organization.width < extraWidth) { add_new_row_ratio = (organization.height + hDiff) / extraWidth; } else { add_new_row_ratio = (organization.height + hDiff) / organization.width; } if (add_new_row_ratio < 1) add_new_row_ratio = 1 / add_new_row_ratio; if (add_to_row_ratio < 1) add_to_row_ratio = 1 / add_to_row_ratio; return add_to_row_ratio < add_new_row_ratio; }; //If moving the last node from the longest row and adding it to the last //row makes the bounding box smaller, do it. CoSELayout.prototype.shiftToLastRow = function (organization) { var longest = this.getLongestRowIndex(organization); var last = organization.rowWidth.length - 1; var row = organization.rows[longest]; var node = row[row.length - 1]; var diff = node.width + organization.horizontalPadding; // Check if there is enough space on the last row if (organization.width - organization.rowWidth[last] > diff && longest != last) { // Remove the last element of the longest row row.splice(-1, 1); // Push it to the last row organization.rows[last].push(node); organization.rowWidth[longest] = organization.rowWidth[longest] - diff; organization.rowWidth[last] = organization.rowWidth[last] + diff; organization.width = organization.rowWidth[instance.getLongestRowIndex(organization)]; // Update heights of the organization var maxHeight = Number.MIN_VALUE; for (var i = 0; i < row.length; i++) { if (row[i].height > maxHeight) maxHeight = row[i].height; } if (longest > 0) maxHeight += organization.verticalPadding; var prevTotal = organization.rowHeight[longest] + organization.rowHeight[last]; organization.rowHeight[longest] = maxHeight; if (organization.rowHeight[last] < node.height + organization.verticalPadding) organization.rowHeight[last] = node.height + organization.verticalPadding; var finalTotal = organization.rowHeight[longest] + organization.rowHeight[last]; organization.height += finalTotal - prevTotal; this.shiftToLastRow(organization); } }; CoSELayout.prototype.tilingPreLayout = function () { if (CoSEConstants.TILE) { // Find zero degree nodes and create a compound for each level this.groupZeroDegreeMembers(); // Tile and clear children of each compound this.clearCompounds(); // Separately tile and clear zero degree nodes for each level this.clearZeroDegreeMembers(); } }; CoSELayout.prototype.tilingPostLayout = function () { if (CoSEConstants.TILE) { this.repopulateZeroDegreeMembers(); this.repopulateCompounds(); } }; // ----------------------------------------------------------------------------- // Section: Tree Reduction methods // ----------------------------------------------------------------------------- // Reduce trees CoSELayout.prototype.reduceTrees = function () { var prunedNodesAll = []; var containsLeaf = true; var node; while (containsLeaf) { var allNodes = this.graphManager.getAllNodes(); var prunedNodesInStepTemp = []; containsLeaf = false; for (var i = 0; i < allNodes.length; i++) { node = allNodes[i]; if (node.getEdges().length == 1 && !node.getEdges()[0].isInterGraph && node.getChild() == null) { prunedNodesInStepTemp.push([node, node.getEdges()[0], node.getOwner()]); containsLeaf = true; } } if (containsLeaf == true) { var prunedNodesInStep = []; for (var j = 0; j < prunedNodesInStepTemp.length; j++) { if (prunedNodesInStepTemp[j][0].getEdges().length == 1) { prunedNodesInStep.push(prunedNodesInStepTemp[j]); prunedNodesInStepTemp[j][0].getOwner().remove(prunedNodesInStepTemp[j][0]); } } prunedNodesAll.push(prunedNodesInStep); this.graphManager.resetAllNodes(); this.graphManager.resetAllEdges(); } } this.prunedNodesAll = prunedNodesAll; }; // Grow tree one step CoSELayout.prototype.growTree = function (prunedNodesAll) { var lengthOfPrunedNodesInStep = prunedNodesAll.length; var prunedNodesInStep = prunedNodesAll[lengthOfPrunedNodesInStep - 1]; var nodeData; for (var i = 0; i < prunedNodesInStep.length; i++) { nodeData = prunedNodesInStep[i]; this.findPlaceforPrunedNode(nodeData); nodeData[2].add(nodeData[0]); nodeData[2].add(nodeData[1], nodeData[1].source, nodeData[1].target); } prunedNodesAll.splice(prunedNodesAll.length - 1, 1); this.graphManager.resetAllNodes(); this.graphManager.resetAllEdges(); }; // Find an appropriate position to replace pruned node, this method can be improved CoSELayout.prototype.findPlaceforPrunedNode = function (nodeData) { var gridForPrunedNode; var nodeToConnect; var prunedNode = nodeData[0]; if (prunedNode == nodeData[1].source) { nodeToConnect = nodeData[1].target; } else { nodeToConnect = nodeData[1].source; } var startGridX = nodeToConnect.startX; var finishGridX = nodeToConnect.finishX; var startGridY = nodeToConnect.startY; var finishGridY = nodeToConnect.finishY; var upNodeCount = 0; var downNodeCount = 0; var rightNodeCount = 0; var leftNodeCount = 0; var controlRegions = [upNodeCount, rightNodeCount, downNodeCount, leftNodeCount]; if (startGridY > 0) { for (var i = startGridX; i <= finishGridX; i++) { controlRegions[0] += this.grid[i][startGridY - 1].length + this.grid[i][startGridY].length - 1; } } if (finishGridX < this.grid.length - 1) { for (var i = startGridY; i <= finishGridY; i++) { controlRegions[1] += this.grid[finishGridX + 1][i].length + this.grid[finishGridX][i].length - 1; } } if (finishGridY < this.grid[0].length - 1) { for (var i = startGridX; i <= finishGridX; i++) { controlRegions[2] += this.grid[i][finishGridY + 1].length + this.grid[i][finishGridY].length - 1; } } if (startGridX > 0) { for (var i = startGridY; i <= finishGridY; i++) { controlRegions[3] += this.grid[startGridX - 1][i].length + this.grid[startGridX][i].length - 1; } } var min = Integer.MAX_VALUE; var minCount; var minIndex; for (var j = 0; j < controlRegions.length; j++) { if (controlRegions[j] < min) { min = controlRegions[j]; minCount = 1; minIndex = j; } else if (controlRegions[j] == min) { minCount++; } } if (minCount == 3 && min == 0) { if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[2] == 0) { gridForPrunedNode = 1; } else if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[3] == 0) { gridForPrunedNode = 0; } else if (controlRegions[0] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) { gridForPrunedNode = 3; } else if (controlRegions[1] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) { gridForPrunedNode = 2; } } else if (minCount == 2 && min == 0) { var random = Math.floor(Math.random() * 2); if (controlRegions[0] == 0 && controlRegions[1] == 0) { ; if (random == 0) { gridForPrunedNode = 0; } else { gridForPrunedNode = 1; } } else if (controlRegions[0] == 0 && controlRegions[2] == 0) { if (random == 0) { gridForPrunedNode = 0; } else { gridForPrunedNode = 2; } } else if (controlRegions[0] == 0 && controlRegions[3] == 0) { if (random == 0) { gridForPrunedNode = 0; } else { gridForPrunedNode = 3; } } else if (controlRegions[1] == 0 && controlRegions[2] == 0) { if (random == 0) { gridForPrunedNode = 1; } else { gridForPrunedNode = 2; } } else if (controlRegions[1] == 0 && controlRegions[3] == 0) { if (random == 0) { gridForPrunedNode = 1; } else { gridForPrunedNode = 3; } } else { if (random == 0) { gridForPrunedNode = 2; } else { gridForPrunedNode = 3; } } } else if (minCount == 4 && min == 0) { var random = Math.floor(Math.random() * 4); gridForPrunedNode = random; } else { gridForPrunedNode = minIndex; } if (gridForPrunedNode == 0) { prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() - nodeToConnect.getHeight() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getHeight() / 2); } else if (gridForPrunedNode == 1) { prunedNode.setCenter(nodeToConnect.getCenterX() + nodeToConnect.getWidth() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getWidth() / 2, nodeToConnect.getCenterY()); } else if (gridForPrunedNode == 2) { prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() + nodeToConnect.getHeight() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getHeight() / 2); } else { prunedNode.setCenter(nodeToConnect.getCenterX() - nodeToConnect.getWidth() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getWidth() / 2, nodeToConnect.getCenterY()); } }; module.exports = CoSELayout; /***/ }), /* 7 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var coseBase = {}; coseBase.layoutBase = __webpack_require__(0); coseBase.CoSEConstants = __webpack_require__(1); coseBase.CoSEEdge = __webpack_require__(2); coseBase.CoSEGraph = __webpack_require__(3); coseBase.CoSEGraphManager = __webpack_require__(4); coseBase.CoSELayout = __webpack_require__(6); coseBase.CoSENode = __webpack_require__(5); module.exports = coseBase; /***/ }) /******/ ]); });