From d2112d88bb536f8e08eb3ce123a2b2230c4411f9 Mon Sep 17 00:00:00 2001
From: xyc <jc_xiong@hotmail.com>
Date: 星期二, 15 十月 2024 14:08:31 +0800
Subject: [PATCH] 修改自动排版算法
---
modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java | 6
modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java | 781 +++++++++++++++----------------------------------------
2 files changed, 216 insertions(+), 571 deletions(-)
diff --git a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java
index 0714fdb..56aa5ed 100644
--- a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java
+++ b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/model/RbdTreeNode.java
@@ -29,14 +29,16 @@
private double descentWidth;
private double descentHeight;
+ // 閫昏緫涓婄殑铏氳妭鐐圭殑瀹藉害鍙婇珮搴︽垨瀹炶妭鐐瑰姞涓婄嚎瀹藉悗鐨勫��
private double blockWidth;
private double blockHeight;
private double blockWidthNum;
private double blockHeightNum;
- private double myWidth;
- private double myHeight;
+ // 瀹炶妭鐐圭殑瀹藉害鍙婇珮搴�
+ private double objectWidth;
+ private double objectHeight;
private List<RbdTreeNode> children = new ArrayList<>();
diff --git a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
index b32146d..b1c6c3c 100644
--- a/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
+++ b/modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java
@@ -1,6 +1,5 @@
package com.zt.life.modules.mainPart.taskReliability.service;
-import cn.hutool.core.convert.Convert;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.zt.common.service.BaseService;
@@ -10,7 +9,6 @@
import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
import com.zt.life.modules.mainPart.basicInfo.model.ProductImg;
import com.zt.life.modules.mainPart.taskReliability.dao.*;
-import com.zt.life.modules.mainPart.taskReliability.dto.ModelLinePairDto;
import com.zt.life.modules.mainPart.taskReliability.model.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
@@ -40,33 +38,6 @@
public static final String OPE_TYPE_SWITCH = "switch";
public static final String OPE_TYPE_VOTE = "vote";
public static final String OPE_TYPE_BRIDGE = "bridge";
-
- // 鑺傜偣
- /* 鑷姩甯冨眬锛歴tart涓巈nd鐨勫ぇ灏� */
- public static final int LAYOUT_START_END_SIZE_X = 60;
- public static final int LAYOUT_START_END_SIZE_Y = 40;
- /* 鑷姩甯冨眬锛氳櫄妗嗙殑澶у皬 */
- public static final int LAYOUT_DASHED_BOX_SIZE_X = 60;
- public static final int LAYOUT_DASHED_BOX_SIZE_Y = 40;
- /* 鑷姩甯冨眬锛氶�昏緫杩愮畻绗︾殑澶у皬 */
- public static final int LAYOUT_OPE_NODE_SIZE_X = 50;
- public static final int LAYOUT_OPE_NODE_SIZE_Y = 50;
- /* 鑷姩甯冨眬锛氳澶囪妭鐐圭殑澶у皬 */
- public static final int LAYOUT_DEVICE_NODE_SIZE_X = 60;
- public static final int LAYOUT_DEVICE_NODE_SIZE_Y = 60;
- /* 鑷姩甯冨眬锛歝onnect鐨勫ぇ灏� */
- public static final int LAYOUT_CONNECT_SIZE_X = 10;
- public static final int LAYOUT_CONNECT_SIZE_Y = 10;
-
- // 鍗曞厓鏍硷紙瀛樻斁鑺傜偣锛�
- /* 鑷姩甯冨眬锛氬崟鍏冩牸澶у皬 */
- public static final int LAYOUT_CELL_SIZE_X = 120;
- public static final int LAYOUT_CELL_SIZE_Y = 120;
- /* 鑷姩甯冨眬锛氳妭鐐瑰崰鎹崟鍏冩牸鏁伴噺 */
- public static final int LAYOUT_CELL_NUM_NODE_X = 1;
- public static final int LAYOUT_CELL_NUM_NODE_Y = 1;
- public static final int LAYOUT_CELL_NUM_CONNECT_X = 1;
- public static final int LAYOUT_CELL_NUM_CONNECT_Y = 1;
@Autowired
private ModelLineDao modelLineDao;
@@ -167,63 +138,171 @@
// 1. 瑙ｆ瀽鍑鸿妭鐐逛笌杈�
getNodeAndLineFromRbd(modelRbd.getId(), rbdJsonArray, modelNodeList, modelLineList, productImgList);
+
// 2. 杞崲涓烘爲鍨嬬粨鏋�
RbdTreeNode root = recognizeRbd(modelNodeList, modelLineList);
- // 3. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿澶у皬
+ // 3. 灏嗘ˉ鑱旇浆鎹负3鏀矾鐨勫苟鑱�
+ convertBridgeToThreeBranchParallel(root);
+ // 4. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿澶у皬
+ calcLayoutSize(root);
- // 4. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿鍙傛暟锛坸銆亂鍧愭爣锛�
+ // 5. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿鍙傛暟锛坸銆亂鍧愭爣锛�
+ root.setBlockX(0);
+ root.setBlockY(0);
+ Map<String, RbdTreeNode> nodeMap = new HashMap<>();
+ calcPosition(rbdJsonArray, root, nodeMap, false);
+ setEdgeRouter(rbdJsonArray, nodeMap);
- // 5. 淇濆瓨鑷姩甯冨眬妯″瀷
+ // 6. 淇濆瓨鑷姩甯冨眬妯″瀷
JSONObject jsonObject = new JSONObject();
jsonObject.put("cells", rbdJsonArray);
modelRbd.setContent(jsonObject.toString());
modelRbdDao.updateById(modelRbd);
return result;
-/*
- // 3. 澶嶅埗浜у搧鑺傜偣(node)鍒發ist
- List<ModelNode> modelNodeAndVnodeList = modelNodeList.stream().filter(item ->
- "node".equals(item.getNodeType())).collect(Collectors.toList());
- // 4. 涓嶆柇灏嗗熀鏈ā鍨嬶紙涓茶仈銆佸苟鑱斻�佹梺鑱斻�佽〃鍐炽�佹ˉ鑱旓級鏇挎崲涓鸿櫄鑺傜偣鑰岀畝鍖栧浘褰紝鐩磋嚦鏃犳硶绠�鍖栦负姝€��
-// result = getAlgorithmFromRbd(modelRbd, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);
+ }
- // 6. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿澶у皬
- calcLayoutSize(modelRbd, algorithmList, modelNodeAndVnodeList);
- Collections.reverse(algorithmList);
- RbdTreeNode root2 = listToTree(algorithmList.get(0).getComputerList(), algorithmList, modelNodeAndVnodeList);
+ private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap, Boolean lastIsSeries) {
+ if ("node,start,end,connect,parallel,switch,vote,bridge".contains(block.getNodeType())) {
+ setNodePositionXY(rbdJsonArray, block, nodeMap);
+ } else {
- RbdTreeNode root = new RbdTreeNode();
+ Double descentWidth = block.getDescentWidth();
+ if (descentWidth == null || descentWidth == 0.0) {
+ descentWidth = block.getBlockWidth();
+ }
+ Double descentHeight = block.getDescentHeight();
+ if (descentHeight == null || descentHeight == 0.0) {
+ descentHeight = block.getBlockHeight();
+ }
+ List<RbdTreeNode> children = block.getChildren();
+ if (OPE_TYPE_SERIES.equals(block.getAlgorithmType())) {
+ Double subBlockX = block.getBlockX();
+ for (RbdTreeNode child : children) {
- root.setId(Convert.toLong("20000"));
+ double selfBlockWidth = child.getBlockWidth() * descentWidth / block.getBlockWidth();
+ child.setDescentWidth(selfBlockWidth);
+ child.setBlockWidth(selfBlockWidth);
+ if (lastIsSeries)
+ child.setDescentHeight(descentHeight);
+ else
+ child.setDescentHeight(block.getBlockHeight());
- root.setName("end");
- root.setNodeType("vnode");
- root.setAlgorithmType("parallel");
- root.setPicId("20000");
- root.setPairStartNodeId("10000");
+ child.setBlockHeight(block.getBlockHeight() );
+ child.setBlockY(block.getBlockY());
+ child.setBlockX(subBlockX);
+ calcPosition(rbdJsonArray, child, nodeMap,true);
+ subBlockX = subBlockX + selfBlockWidth;
+ }
+ } else {
+ Double subBlockY = block.getBlockY() + (descentHeight - block.getObjectHeight())/ 2;
+ for (RbdTreeNode child : children) {
+ child.setDescentWidth(block.getBlockWidth());
+ child.setDescentHeight(block.getBlockHeight());
- root.setBlockWidthNum(root2.getBlockWidthNum() + 2);
- root.setBlockHeightNum(root2.getBlockHeightNum());
- root.getChildren().add(root2);
+ if (!"vnode".equals(child.getNodeType())) {
+ child.setBlockWidth(block.getBlockWidth());
+ }
- // 7. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿鍙傛暟锛坸銆亂鍧愭爣锛�
- root.setBlockX(0);
- root.setBlockY(0);
+ child.setBlockX(block.getBlockX());
+ child.setBlockY(subBlockY);
+ calcPosition(rbdJsonArray, child, nodeMap, false);
+ subBlockY = subBlockY + child.getBlockHeight();
+ }
+ }
+ }
+ }
- Map<String, RbdTreeNode> nodeMap = new HashMap<>();
- calcPosition(rbdJsonArray, root, nodeMap);
- setEdgeRouter(rbdJsonArray, nodeMap);
+ private void setNodePositionXY(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
+ Double x = block.getBlockX() + (block.getBlockWidth() - block.getObjectWidth()) / 2;
+ Double y = block.getBlockY() + (block.getBlockHeight() - block.getObjectHeight()) / 2;
+ block.setX(x);
+ block.setY(y);
+ nodeMap.put(block.getPicId(), block);
+ setRbdNodePosition(rbdJsonArray, block.getPicId(), x, y);
+ }
- JSONObject jsonObject = new JSONObject();
- jsonObject.put("cells", rbdJsonArray);
- modelRbd.setContent(jsonObject.toString());
- // calcLayoutPosition(modelRbd, algorithmList, modelNodeAndVnodeList);
+ private void setRbdNodePosition(JSONArray rbdJsonArray,
+ String id,
+ double x,
+ double y) {
+ for (int i = 0; i < rbdJsonArray.size(); i++) {
+ JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
+ if (id.equals(jsonObject.get("id").toString())) {
+ JsonUtils2.setJsonValueByPath(jsonObject, "position/x".split("/"), x);
+ JsonUtils2.setJsonValueByPath(jsonObject, "position/y".split("/"), y);
+ }
+ }
+ }
- // 8. 淇濆瓨鑷姩甯冨眬妯″瀷
- // 鏇存柊RBD鏁版嵁
-// modelRbd.setAutoLayoutContent("娴嬭瘯鏂囧瓧");
-// modelRbdDao.updateById(modelRbd);
-*/
+ private void setEdgeRouter(JSONArray rbdJsonArray, Map<String, RbdTreeNode> nodeMap) {
+ for (int i = 0; i < rbdJsonArray.size(); i++
+ ) {
+ JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
+ if (jsonObject.get("shape").equals("edge")) {
+ String sourceId = JsonUtils2.getJsonValueByPath(jsonObject, "source/cell".split("/")).toString();
+ String targetId = JsonUtils2.getJsonValueByPath(jsonObject, "target/cell".split("/")).toString();
+ RbdTreeNode sourceNode = nodeMap.get(sourceId);
+ RbdTreeNode targetNode = nodeMap.get(targetId);
+ if (sourceNode != null) {
+ if ("connect".equals(sourceNode.getNodeType()) && !"10000".equals(sourceId)) {
+ if (sourceNode.getY() + sourceNode.getObjectHeight() / 2 == targetNode.getY() + targetNode.getObjectHeight() / 2) {
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"), "right".split(","));
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"), "left".split(","));
+ } else {
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"), "top,bottom".split(","));
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"), "left".split(","));
+ }
+ }
+ }
+ if (targetNode != null) {
+ if ("parallel,vote,switch,bridge".contains(targetNode.getNodeType())) {
+ if (sourceNode.getY() + sourceNode.getObjectHeight() / 2 == targetNode.getY() + targetNode.getObjectHeight() / 2) {
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"), "right".split(""));
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"), "left".split(""));
+ } else {
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"), "right".split(""));
+ JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"), "top,bottom".split(""));
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private void calcLayoutSize(RbdTreeNode root) {
+ double childrenWidth = 0.0;
+ double childrenHeight = 0.0;
+ double lineWidth = 80;
+ double lineHeight = 80;
+ if (!"vnode".equals(root.getNodeType())) {
+ root.setBlockWidth(root.getObjectWidth() + lineWidth);
+ root.setBlockHeight(root.getObjectHeight() + lineHeight);
+ } else {
+ for (RbdTreeNode treeNode : root.getChildren()) {
+ calcLayoutSize(treeNode);
+ if ("series".equals(root.getAlgorithmType())) {
+ childrenWidth += treeNode.getBlockWidth();
+ childrenHeight = Math.max(childrenHeight, treeNode.getBlockHeight());
+ } else if ("parallel,switch,vote".contains(root.getAlgorithmType())) {
+ childrenWidth = Math.max(childrenWidth, treeNode.getBlockWidth());
+ childrenHeight += treeNode.getBlockHeight();
+ }
+ }
+ if ("bridge".equals(root.getAlgorithmType())) {
+ childrenWidth = Math.max(root.getChildren().get(0).getBlockWidth() + root.getChildren().get(1).getBlockWidth(),
+ root.getChildren().get(2).getBlockWidth());
+ childrenWidth = Math.max(root.getChildren().get(3).getBlockWidth() + root.getChildren().get(4).getBlockWidth(),
+ childrenWidth);
+ childrenHeight += Math.max(root.getChildren().get(0).getBlockHeight(), root.getChildren().get(1).getBlockHeight());
+ childrenHeight += root.getChildren().get(2).getBlockHeight();
+ childrenHeight += Math.max(root.getChildren().get(3).getBlockHeight(), root.getChildren().get(4).getBlockHeight());
+ }
+ root.setObjectWidth(childrenWidth);
+ root.setObjectHeight(childrenHeight);
+ root.setBlockWidth(childrenWidth);
+ root.setBlockHeight(childrenHeight);
+ }
}
private void getNodeAndLineFromRbd(Long modelId,
@@ -357,7 +436,7 @@
}
private RbdTreeNode recognizeRbd(List<ModelNode> modelNodeList,
- List<ModelLine> modelLineList) {
+ List<ModelLine> modelLineList) {
Map<String, Integer> vnodeCounter = new HashMap<>();
vnodeCounter.put("vnodeCounter", 0);
RbdTreeNode root = new RbdTreeNode();
@@ -377,8 +456,8 @@
endNode.setNodeType("end");
endNode.setPicId(end.getPicId());
endNode.setPairStartNodeId(end.getPairStartNodeId());
- endNode.setMyWidth(end.getWidth());
- endNode.setMyHeight(end.getHeight());
+ endNode.setObjectWidth(end.getWidth());
+ endNode.setObjectHeight(end.getHeight());
root.getChildren().add(endNode);
ModelLine lineRight = modelLineList.stream().filter(item ->
item.getEndCell().equals(end.getPicId())).collect(Collectors.toList()).get(0);
@@ -393,13 +472,13 @@
}
private void recognizeOneBranch(RbdTreeNode parent,
- ModelLine lineRight, // 涓茶仈鐨勮捣濮嬬嚎锛堝彸杈癸級
- ModelLine lineLeft, // 涓茶仈鐨勭粨鏉熺嚎锛堝乏杈癸級
- List<ModelNode> modelNodeList,
- List<ModelLine> modelLineList,
- Map<String, Integer> vnodeCounter) {
+ ModelLine lineRight, // 涓茶仈鐨勮捣濮嬬嚎锛堝彸杈癸級
+ ModelLine lineLeft, // 涓茶仈鐨勭粨鏉熺嚎锛堝乏杈癸級
+ List<ModelNode> modelNodeList,
+ List<ModelLine> modelLineList,
+ Map<String, Integer> vnodeCounter) {
ModelLine inLine = lineRight;
- for (;;) {
+ for (; ; ) {
ModelLine searchLine = inLine;
ModelNode node = modelNodeList.stream().filter(item ->
searchLine.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
@@ -410,8 +489,8 @@
treeNode.setNodeType(node.getNodeType());
treeNode.setPicId(node.getPicId());
treeNode.setDataId(node.getDataId());
- treeNode.setMyWidth(node.getWidth());
- treeNode.setMyHeight(node.getHeight());
+ treeNode.setObjectWidth(node.getWidth());
+ treeNode.setObjectHeight(node.getHeight());
parent.getChildren().add(treeNode);
inLine = modelLineList.stream().filter(item ->
item.getEndCell().equals(node.getPicId())).collect(Collectors.toList()).get(0);
@@ -421,8 +500,8 @@
treeNode.setName(node.getNodeType());
treeNode.setNodeType(node.getNodeType());
treeNode.setPicId(node.getPicId());
- treeNode.setMyWidth(node.getWidth());
- treeNode.setMyHeight(node.getHeight());
+ treeNode.setObjectWidth(node.getWidth());
+ treeNode.setObjectHeight(node.getHeight());
parent.getChildren().add(treeNode);
break;
} else if ("connect".equals(node.getNodeType())) {
@@ -444,8 +523,8 @@
treeNode.setName(connect.getNodeType());
treeNode.setNodeType(connect.getNodeType());
treeNode.setPicId(connect.getPicId());
- treeNode.setMyWidth(connect.getWidth());
- treeNode.setMyHeight(connect.getHeight());
+ treeNode.setObjectWidth(connect.getWidth());
+ treeNode.setObjectHeight(connect.getHeight());
subNode.getChildren().add(treeNode);
RbdTreeNode subNodeOpe = new RbdTreeNode();
subNodeOpe.setAlgorithmType(node.getNodeType());
@@ -463,8 +542,8 @@
treeNode.setNodeType(node.getNodeType());
treeNode.setPicId(node.getPicId());
treeNode.setPairStartNodeId(node.getPairStartNodeId());
- treeNode.setMyWidth(node.getWidth());
- treeNode.setMyHeight(node.getHeight());
+ treeNode.setObjectWidth(node.getWidth());
+ treeNode.setObjectHeight(node.getHeight());
subNode.getChildren().add(treeNode);
recognizeOpeBlock(subNodeOpe,
node,
@@ -483,10 +562,10 @@
}
private void recognizeOpeBlock(RbdTreeNode parent,
- ModelNode rightNode, // rbd涓殑鍙宠妭鐐癸紙鍖呮嫭end鍙�4绉嶈繍绠楃锛�
- List<ModelNode> modelNodeList,
- List<ModelLine> modelLineList,
- Map<String, Integer> vnodeCounter) {
+ ModelNode rightNode, // rbd涓殑鍙宠妭鐐癸紙鍖呮嫭end鍙�4绉嶈繍绠楃锛�
+ List<ModelNode> modelNodeList,
+ List<ModelLine> modelLineList,
+ Map<String, Integer> vnodeCounter) {
if ("parallel,vote,switch".contains(parent.getAlgorithmType())) {
ModelNode searchNode = rightNode;
List<ModelLine> lines = modelLineList.stream().filter(item ->
@@ -506,7 +585,7 @@
parent.getChildren().add(subNode);
recognizeOneBranch(subNode, line, null, modelNodeList, modelLineList, vnodeCounter);
} else {
- recognizeOneBranch(parent, line,null, modelNodeList, modelLineList, vnodeCounter);
+ recognizeOneBranch(parent, line, null, modelNodeList, modelLineList, vnodeCounter);
}
}
} else if ("bridge".contains(parent.getAlgorithmType())) {
@@ -605,7 +684,7 @@
/**
* 鎸夎嚜涓婅�屼笅鐨勯『搴忔帓搴�
- */
+ */
private List<ModelLine> sortLine(List<ModelLine> lines,
List<ModelNode> modelNodeList) {
for (ModelLine line : lines) {
@@ -696,9 +775,9 @@
}
private void createAlgorithm(Long modelId,
- RbdTreeNode root,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList) {
+ RbdTreeNode root,
+ List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList) {
List<RbdTreeNode> children = root.getChildren();
if (children.size() == 0) {
ModelNode node = new ModelNode();
@@ -743,14 +822,15 @@
* 瀵规爲褰㈢粨鏋勮繘琛岄澶勭悊锛屽寘鎷細
* 1锛夊皢root鐨刟lgorithmType鏇挎崲涓篹nd锛屽苟鍘绘帀start鍜宔nd鑺傜偣
* 2锛塻tart涓巈nd闂村彧鏈�1涓�昏緫杩愮畻鍧楋紝鍒欏幓鎺夋渶澶栧眰鐨剆eries
+ *
* @param root
*/
private void deleteStartEnd(RbdTreeNode root) {
root.setAlgorithmType("end");
List<RbdTreeNode> children = root.getChildren();
- children.remove(children.size()-1);
+ children.remove(children.size() - 1);
children.remove(0);
- if (children.size()>1 ||
+ if (children.size() > 1 ||
!"vnode".equals(children.get(0).getNodeType())) {
RbdTreeNode subNode = new RbdTreeNode();
subNode.setAlgorithmType("series");
@@ -766,7 +846,8 @@
/**
* 瀵规爲褰㈢粨鏋勮繘琛岄澶勭悊锛�
- * 鍘绘帀閫昏緫杩愮畻鍧椾腑鐢ㄤ簬鎺掔増鐨勫灞俿eries
+ * 鍘绘帀閫昏緫杩愮畻鍧椾腑鐢ㄤ簬鎺掔増鐨勫灞俿eries
+ *
* @param root
*/
private void deleteSeriesForAutoArrange(RbdTreeNode root) {
@@ -782,50 +863,41 @@
}
}
- private void setEdgeRouter(JSONArray rbdJsonArray, Map<String, RbdTreeNode> nodeMap) {
- for (int i = 0; i < rbdJsonArray.size(); i++
- ) {
- JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
- if (jsonObject.get("shape").equals("edge")) {
- String sourceId = JsonUtils2.getJsonValueByPath(jsonObject, "source/cell".split("/")).toString();
- String targetId = JsonUtils2.getJsonValueByPath(jsonObject, "target/cell".split("/")).toString();
- RbdTreeNode sourceNode = nodeMap.get(sourceId);
- RbdTreeNode targetNode = nodeMap.get(targetId);
- if (sourceNode != null) {
- if ("connect".equals(sourceNode.getNodeType()) && !"10000".equals(sourceId)){
- if (sourceNode.getY()+sourceNode.getMyHeight()/2 == targetNode.getY()+targetNode.getMyHeight()/2){
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(","));
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(","));
- }else{
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"top,bottom".split(","));
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(","));
- }
- }
- }
- if (targetNode != null) {
- if ("parallel,vote".contains(targetNode.getNodeType())){
- if (sourceNode.getY()+sourceNode.getMyHeight()/2 == targetNode.getY()+targetNode.getMyHeight()/2){
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(""));
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"left".split(""));
- }else{
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/startDirections".split("/"),"right".split(""));
- JsonUtils2.setJsonValueByPath(jsonObject, "router/args/endDirections".split("/"),"top,bottom".split(""));
- }
- }
- }
+ /**
+ * 鐢ㄤ簬鑷姩鎺掔増锛氬皢妗ヨ仈杞崲涓�3鏀矾鐨勫苟鑱�
+ * @param root
+ * @return
+ */
+ private void convertBridgeToThreeBranchParallel(RbdTreeNode root) {
+ List<RbdTreeNode> children = root.getChildren();
+ for (RbdTreeNode treeNode : children) {
+ if ("bridge".equals(treeNode.getAlgorithmType())) {
+ treeNode.setAlgorithmType("parallel");
+ List<RbdTreeNode> list = new ArrayList<>();
+ RbdTreeNode subNode = new RbdTreeNode();
+ subNode.setAlgorithmType("series");
+ subNode.setId(UUIDUtil.generateId());
+ subNode.setName("v10000");
+ subNode.setNodeType("vnode");
+ subNode.getChildren().add(treeNode.getChildren().get(0));
+ subNode.getChildren().add(treeNode.getChildren().get(1));
+ list.add(subNode);
+ list.add(treeNode.getChildren().get(2));
+ subNode = new RbdTreeNode();
+ subNode.setAlgorithmType("series");
+ subNode.setId(UUIDUtil.generateId());
+ subNode.setName("v10001");
+ subNode.setNodeType("vnode");
+ subNode.getChildren().add(treeNode.getChildren().get(3));
+ subNode.getChildren().add(treeNode.getChildren().get(4));
+ list.add(subNode);
+ treeNode.setChildren(list);
}
+ convertBridgeToThreeBranchParallel(treeNode);
}
}
- private void setNodePositionXY(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
- Double x = block.getBlockX() + (block.getBlockWidth() - block.getMyWidth()) / 2;
- Double y = block.getBlockY() + (block.getBlockHeight() - block.getMyHeight()) / 2;
- block.setX(x);
- block.setY(y);
- nodeMap.put(block.getPicId(),block);
- setRbdNodePosition(rbdJsonArray, block.getPicId(), x, y);
- }
-
+/*
private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
if (block.getNodeType().equals("node")) {
setNodePositionXY(rbdJsonArray, block,nodeMap);
@@ -870,8 +942,8 @@
// 璁剧疆connect鐨勪綅缃�
RbdTreeNode connectBlock = new RbdTreeNode();
- connectBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/width"));
- connectBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/height"));
+ connectBlock.setObjectWidth(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/width"));
+ connectBlock.setObjectHeight(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/height"));
connectBlock.setNodeType("connect");
connectBlock.setPicId(block.getPairStartNodeId());
connectBlock.setBlockX(block.getBlockX());
@@ -898,8 +970,8 @@
opeBlock.setPicId(block.getPicId());
opeBlock.setNodeType("parallel");
- opeBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/width"));
- opeBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/height"));
+ opeBlock.setObjectWidth(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/width"));
+ opeBlock.setObjectHeight(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/height"));
opeBlock.setBlockX(block.getBlockX() + blockWidth - LAYOUT_CELL_SIZE_X);
opeBlock.setBlockY(firstSubBlockY);
opeBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
@@ -909,435 +981,6 @@
}
}
-
- private RbdTreeNode listToTree(String id,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList) {
-
- List<Algorithm> algos = algorithmList.stream().filter(item ->
- id.equals(item.getId().toString())).collect(Collectors.toList());
-
- RbdTreeNode subNode = new RbdTreeNode();
- subNode.setId(Convert.toLong(id));
- ModelNode nd = modelNodeAndVnodeList.stream().filter(item ->
- id.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- subNode.setName(nd.getName());
- subNode.setNodeType(nd.getNodeType());
- subNode.setPicId(nd.getPicId());
-
- if (!"vnode".equals(nd.getNodeType())) {
- subNode.setMyWidth(nd.getWidth());
- subNode.setMyHeight(nd.getHeight());
- }
- subNode.setBlockWidthNum(nd.getVnodeCellNumX());
- subNode.setBlockHeightNum(nd.getVnodeCellNumY());
- subNode.setPairStartNodeId(nd.getPairStartNodeId());
- subNode.setPairEndNodeId(nd.getPairEndNodeId());
- if (algos.size() > 0) {
- Algorithm algo = algos.get(0);
- subNode.setAlgorithmType(algo.getAlgorithmType());
- String str = algo.getComputerList();
- String[] ids = str.split(",");
- for (String subId : ids) {
- subNode.getChildren().add(listToTree(subId, algorithmList, modelNodeAndVnodeList));
- }
- }
- return subNode;
- }
-
- /*
- */
-
- /**
- * 鏍规嵁椤跺眰RBD鐨勪綅缃紙x锛寉锛夛紝鑷《鍚戜笅閫掑綊璁＄畻鍚勪釜鑺傜偣鐨勪綅缃紙x锛寉锛�
- *
- * @param modelRbd
- * @param algorithmList
- * @param modelNodeAndVnodeList
- *//*
-
- private void calcLayoutPosition(ModelRbd modelRbd,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList) {
- String rbdsonStr = modelRbd.getContent();
- JSONArray rbdJsonArray = new JSONObject(rbdsonStr).getJSONArray("cells");
- Algorithm endAlgo = algorithmList.stream().filter(item ->
- "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
- ModelNode topNode = modelNodeAndVnodeList.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm topAlgo = algorithmList.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- // 灏唗opNode鐨勫潗鏍囧畾涓篊ell(0锛�0)锛屽弽绠楁墍鏈夎妭鐐圭殑鍧愭爣
- // 1. 璁＄畻鑺傜偣鐨凜ell浣嶇疆
- calcNodeLayoutPositionCell(rbdJsonArray, algorithmList, modelNodeAndVnodeList, topNode, topAlgo, 0, 0,
- topNode.getVnodeCellNumX(), topNode.getVnodeCellNumY());
- // 2. 璁＄畻鑺傜偣鐨剎锛寉鍧愭爣浣嶇疆
- calcNodeLayoutPosition(rbdJsonArray, algorithmList, modelNodeAndVnodeList, topNode, topAlgo);
- // 3. 璁剧疆start鐨勪綅缃�
- double distance = 200.0;
- double y = (topNode.getPositionCellY() + topNode.getVnodeCellNumY() / 2) * LAYOUT_CELL_SIZE_Y + (LAYOUT_CELL_SIZE_Y - LAYOUT_START_END_SIZE_Y) / 2;
- setRbdNodePosition(rbdJsonArray, "10000", 0 - distance, y);
- // 4. 璁剧疆end鐨勪綅缃�
- double x = topNode.getVnodeCellNumX() * LAYOUT_CELL_SIZE_X + distance - LAYOUT_START_END_SIZE_X;
- setRbdNodePosition(rbdJsonArray, "20000", x, y);
- JSONObject jsonObject = new JSONObject();
- jsonObject.put("cells", rbdJsonArray);
- modelRbd.setContent(jsonObject.toString());
- }
*/
-/*
- // 閫掑綊鍑芥暟锛堣绠楀悇鑺傜偣鐨剎锛寉鍧愭爣浣嶇疆锛�
- private void calcNodeLayoutPosition(JSONArray rbdJsonArray,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode node,
- Algorithm algo) {
- // 鏈娇鐢ㄨ澶囩殑瀹為檯瀹姐�侀珮
- double x;
- double y;
- if ("node".equals(node.getNodeType())) {
- x = node.getPositionCellX() * LAYOUT_CELL_SIZE_X + (LAYOUT_CELL_SIZE_X - LAYOUT_DEVICE_NODE_SIZE_X) / 2;
- y = node.getPositionCellY() * LAYOUT_CELL_SIZE_Y + (LAYOUT_CELL_SIZE_Y - LAYOUT_DEVICE_NODE_SIZE_Y) / 2;
- node.setPositionX(x);
- node.setPositionY(y);
- setRbdNodePosition(rbdJsonArray, node.getPicId(), node.getPositionX(), node.getPositionY());
- } else if ("vnode".equals(node.getNodeType())) {
- String[] computerNodeListStr = algo.getComputerList().split(",");
- switch (algo.getAlgorithmType()) {
- case OPE_TYPE_SERIES:
- case OPE_TYPE_PARALLEL:
- case OPE_TYPE_SWITCH:
- case OPE_TYPE_VOTE:
- for (String nodeStr : computerNodeListStr) {
- ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
- nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- List<Algorithm> childAlgos = algorithmList.stream().filter(item ->
- childNode.getId().equals(item.getId())).collect(Collectors.toList());
- Algorithm childAlgo = childAlgos.size() > 0 ? childAlgos.get(0) : null;
- calcNodeLayoutPosition(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- childNode,
- childAlgo);
- }
- if (OPE_TYPE_PARALLEL.equals(algo.getAlgorithmType())
- || OPE_TYPE_SWITCH.equals(algo.getAlgorithmType())
- || OPE_TYPE_VOTE.equals(algo.getAlgorithmType())) {
- // 璁剧疆connect鐨勪綅缃�
- x = node.getPositionCellX() * LAYOUT_CELL_SIZE_X + (LAYOUT_CELL_SIZE_X - LAYOUT_CONNECT_SIZE_X) / 2;
- y = (node.getPositionCellY() + node.getVnodeCellNumY() / 2) * LAYOUT_CELL_SIZE_Y + (LAYOUT_CELL_SIZE_Y - LAYOUT_CONNECT_SIZE_Y) / 2;
- setRbdNodePosition(rbdJsonArray, node.getPairStartNodeId(), x, y);
- // 璁剧疆杩愮畻绗︾殑浣嶇疆
- x = (node.getPositionCellX() + node.getVnodeCellNumX() - 1) * LAYOUT_CELL_SIZE_X + (LAYOUT_CELL_SIZE_X - LAYOUT_OPE_NODE_SIZE_X) / 2;
- y = (node.getPositionCellY() + node.getVnodeCellNumY() / 2) * LAYOUT_CELL_SIZE_Y + (LAYOUT_CELL_SIZE_Y - LAYOUT_OPE_NODE_SIZE_Y) / 2;
- setRbdNodePosition(rbdJsonArray, node.getPicId(), x, y);
- }
- break;
- case OPE_TYPE_BRIDGE:
- break;
- default:
- break;
- }
- }
- }
-
- // 閫掑綊鍑芥暟锛堣绠楀悇鑺傜偣鐨凜ell浣嶇疆锛屼互宸︿笂瑙掍负Cell浣嶇疆0锛�0锛�
- private void calcNodeLayoutPositionCell(JSONArray rbdJsonArray,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode node,
- Algorithm algo,
- double originCellX,
- double originCellY,
- double maxX,
- double maxY) {
- if ("node".equals(node.getNodeType())) {
- //璁剧疆node锛堣澶囪妭鐐癸級Cell浣嶇疆
- double width = LAYOUT_DEVICE_NODE_SIZE_X * maxX;
- double hight = LAYOUT_DEVICE_NODE_SIZE_Y * maxY;
- double x = originCellX + (width - LAYOUT_DEVICE_NODE_SIZE_X) / 2;
- double y = originCellY + (hight - LAYOUT_DEVICE_NODE_SIZE_Y) / 2;
- node.setPositionCellX(x);
- node.setPositionCellY(y);
- } else if ("vnode".equals(node.getNodeType())) {
- String[] computerNodeListStr = algo.getComputerList().split(",");
- switch (algo.getAlgorithmType()) {
- case OPE_TYPE_SERIES:
- case OPE_TYPE_PARALLEL:
- case OPE_TYPE_SWITCH:
- case OPE_TYPE_VOTE:
- double preNodeCellX = 0.0;
- double preNodeCellY = 0.0;
- for (String nodeStr : computerNodeListStr) {
- ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
- nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- List<Algorithm> childAlgos = algorithmList.stream().filter(item ->
- childNode.getId().equals(item.getId())).collect(Collectors.toList());
- Algorithm childAlgo = childAlgos.size() > 0 ? childAlgos.get(0) : null;
- if (OPE_TYPE_SERIES.equals(algo.getAlgorithmType())) {
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- childNode,
- childAlgo,
- originCellX + preNodeCellX,
- originCellY, node.getVnodeCellNumX(), node.getVnodeCellNumY()
- );
- preNodeCellX += childNode.getVnodeCellNumX();
- } else {
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- childNode,
- childAlgo,
- originCellX + 1,
- originCellY + preNodeCellY, node.getVnodeCellNumX(), node.getVnodeCellNumY());
- preNodeCellY += childNode.getVnodeCellNumY();
- }
- }
-*/
-/*
- // 璁剧疆杩愮畻绗︾殑Cell浣嶇疆
- if (OPE_TYPE_SERIES.equals(algo.getAlgorithmType())) {
- node.setPositionCellX(originCellX);
- } else {
- node.setPositionCellX(originCellX + node.getVnodeCellNumX() - 1);
- }
- node.setPositionCellY(originCellY + node.getVnodeCellNumY()/2);
-*//*
-
- // 闇�鑺傜偣浠ｈ〃鏁翠釜閫昏緫鍗曞厓锛屽洜姝ゅ叾鍧愭爣涓簅riginCellX鍜宱riginCellX
- node.setPositionCellX(originCellX);
- node.setPositionCellY(originCellX);
- break;
- case OPE_TYPE_BRIDGE:
-*/
-/*
- ModelNode node1 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[0].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node2 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[1].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node3 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[2].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node4 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[3].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node5 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[4].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm algo1 = algorithmList.stream().filter(item ->
- node1.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm algo2 = algorithmList.stream().filter(item ->
- node2.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm algo3 = algorithmList.stream().filter(item ->
- node3.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm algo4 = algorithmList.stream().filter(item ->
- node4.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm algo5 = algorithmList.stream().filter(item ->
- node5.getId().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- // 1锛岃绠椾笁琛岀殑鎬婚珮搴�
- // 1.1 璁＄畻绗竴琛屼袱涓妭鐐圭殑楂樺害
- int firstRowCellNumY = Math.max(node1.getVnodeCellNumY(), node2.getVnodeCellNumY());
- // 1.2 璁＄畻绗簩琛屾ˉ鑱旇妭鐐圭殑楂樺害
- int secondRowCellNumY = node3.getVnodeCellNumY();
- // 1.3 璁＄畻绗笁琛屼袱涓妭鐐圭殑楂樺害
- int thirdRowCellNumY = Math.max(node4.getVnodeCellNumY(), node5.getVnodeCellNumY());
-// int totalCellNumY = firstRowCellNumY + secondRowCellNumY + thirdRowCellNumY;
- // 2. 璁＄畻涓夎鍚勮妭鐐圭殑鍧愭爣
- // 2.1 璁＄畻绗竴琛屼袱涓妭鐐圭殑鍧愭爣
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- node1,
- algo1,
- originCellX + 1,
- originCellY);
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- node2,
- algo2,
- originCellX + 1 + node1.getPositionCellX(),
- originCellY);
- // 2.2 璁＄畻绗簩琛屾ˉ鑱旇妭鐐圭殑鍧愭爣
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- node3,
- algo3,
- originCellX + 1,
- originCellY + firstRowCellNumY);
- // 2.3 璁＄畻绗笁琛屼袱涓妭鐐圭殑鍧愭爣
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- node4,
- algo4,
- originCellX + 1,
- originCellY + firstRowCellNumY + secondRowCellNumY);
- calcNodeLayoutPositionCell(rbdJsonArray,
- algorithmList,
- modelNodeAndVnodeList,
- node5,
- algo5,
- originCellX + 1 + node4.getPositionCellX(),
- originCellY + firstRowCellNumY + secondRowCellNumY);
- // 2.4 璁＄畻妗ヨ仈杩愮畻绗︾殑鍧愭爣
- node.setPositionCellX(originCellX + 1);
- node.setPositionCellY(originCellY + node.getVnodeCellNumY()/2);
-*//*
-
- break;
- default:
- break;
- }
- }
- }
-*/
- private void setRbdNodePosition(JSONArray rbdJsonArray,
- String id,
- double x,
- double y) {
- for (int i = 0; i < rbdJsonArray.size(); i++) {
- JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
- if (id.equals(jsonObject.get("id").toString())) {
- JsonUtils2.setJsonValueByPath(jsonObject, "position/x".split("/"), x);
- JsonUtils2.setJsonValueByPath(jsonObject, "position/y".split("/"), y);
- }
- }
- }
-
- private Double getRbdNodeInfo(JSONArray rbdJsonArray,
- String picId,
- String path) {
- for (int i = 0; i < rbdJsonArray.size(); i++) {
- JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
- if (picId.equals(jsonObject.get("id").toString())) {
- return Convert.toDouble(JsonUtils2.getJsonValueByPath(jsonObject, path.split("/")));
- }
- }
- return null;
- }
-
- /**
- * 鑷簳鍚戜笂閫掑綊鍚堣鍑烘暣涓猂BD鐨勫ぇ灏忥紙妯悜鍙婄旱鍚戞墍鍗犲崟鍏冩牸鐨勬暟閲忥級
- *
- * @param modelRbd
- * @param algorithmList
- * @param modelNodeAndVnodeList
- */
- private void calcLayoutSize(
- ModelRbd modelRbd,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList) {
- Algorithm endAlgo = algorithmList.stream().filter(item ->
- "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
- ModelNode topNode = modelNodeAndVnodeList.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- Algorithm topAlgo = algorithmList.stream().filter(item ->
- endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- calcNodeLayoutSize(algorithmList, modelNodeAndVnodeList, topNode, topAlgo);
- }
-
- // 閫掑綊鍑芥暟
- private void calcNodeLayoutSize(List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode node,
- Algorithm algo) {
- if ("node".equals(node.getNodeType())) {
- //璁剧疆node锛堣澶囪妭鐐癸級甯冨眬淇℃伅
-// node.setWidth(LAYOUT_DEVICE_NODE_SIZE_X);
-// node.setHeight(LAYOUT_DEVICE_NODE_SIZE_Y);
- node.setCellNumX(LAYOUT_CELL_NUM_NODE_X);
- node.setCellNumY(LAYOUT_CELL_NUM_NODE_Y);
- node.setVnodeCellNumX(node.getCellNumX());
- node.setVnodeCellNumY(node.getCellNumY());
- } else if ("vnode".equals(node.getNodeType())) {
- // 1. 璁剧疆vnode锛堣繍绠楄妭鐐癸級甯冨眬淇℃伅锛堝叾瀹炰覆鑱旀病鏈夎繍绠楃锛屼笉闇�瑕佽缃紝浣嗘槸璁剧疆浜嗕篃娌℃湁鍧忓锛屾墍浠ヤ笉浣滃尯鍒嗭級
-// node.setWidth(LAYOUT_OPE_NODE_SIZE_X);
-// node.setHeight(LAYOUT_OPE_NODE_SIZE_Y);
- node.setCellNumX(LAYOUT_CELL_NUM_NODE_X);
- node.setCellNumY(LAYOUT_CELL_NUM_NODE_Y);
-
- // 2. 璁剧疆铏氳妭鐐瑰竷灞�淇℃伅
- // 2.1 璁剧疆铏氳妭鐐瑰唴鍚勮繍绠楀璞＄殑甯冨眬淇℃伅
- String[] computerNodeListStr = algo.getComputerList().split(",");
- for (String nodeStr : computerNodeListStr) {
- ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
- nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- List<Algorithm> childAlgos = algorithmList.stream().filter(item ->
- childNode.getId().equals(item.getId())).collect(Collectors.toList());
- Algorithm childAlgo = childAlgos.size() > 0 ? childAlgos.get(0) : null;
- calcNodeLayoutSize(algorithmList,
- modelNodeAndVnodeList,
- childNode,
- childAlgo);
- }
- // 2.2 璁剧疆铏氳妭鐐规�荤殑甯冨眬淇℃伅鍒拌繍绠楄妭鐐逛腑
- setVnodeLayoutNum(computerNodeListStr, modelNodeAndVnodeList, node, algo);
- }
- }
-
- private void setVnodeLayoutNum(String[] computerNodeListStr,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode vnode,
- Algorithm algo) {
- int numX = 0;
- int numY = 0;
- // 1. 璁＄畻涓层�佸苟銆佹梺鑱斻�佽〃鍐�
- for (String nodeStr : computerNodeListStr) {
- ModelNode childNode = modelNodeAndVnodeList.stream().filter(item ->
- nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- switch (algo.getAlgorithmType()) {
- case OPE_TYPE_SERIES:
- numX += childNode.getVnodeCellNumX();
- numY = childNode.getVnodeCellNumY() > numY ? childNode.getVnodeCellNumY() : numY;
- break;
- case OPE_TYPE_PARALLEL:
- case OPE_TYPE_SWITCH:
- case OPE_TYPE_VOTE:
- numX = childNode.getVnodeCellNumX() > numX ? childNode.getVnodeCellNumX() : numX;
- numY += childNode.getVnodeCellNumY();
- break;
- default:
- break;
- }
- }
- if (OPE_TYPE_PARALLEL.equals(algo.getAlgorithmType())
- || OPE_TYPE_SWITCH.equals(algo.getAlgorithmType())
- || OPE_TYPE_VOTE.equals(algo.getAlgorithmType())) {
- // 鍔犱笂connect鐨勫ぇ灏�
- numX += LAYOUT_CELL_NUM_CONNECT_X;
- numX += vnode.getCellNumX();
- }
- // 2. 璁＄畻妗ヨ仈
- if (OPE_TYPE_BRIDGE.equals(algo.getAlgorithmType())) {
- // 妗ヨ仈鏀矾绠椾竴琛岋紝鏁翠釜妗ヨ仈鍏�3琛�
- // 2.1 璁＄畻绗竴琛�
- ModelNode node1 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[0].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node2 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[1].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node3 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[2].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node4 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[3].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- ModelNode node5 = modelNodeAndVnodeList.stream().filter(item ->
- computerNodeListStr[4].equals(item.getId().toString())).collect(Collectors.toList()).get(0);
- int numX1 = node1.getCellNumX() + node2.getCellNumX();
- int numY1 = node1.getCellNumY() > node2.getCellNumY() ? node1.getCellNumY() : node2.getCellNumY();
- // 2.2 璁＄畻绗簩琛岋紙妗ヨ仈鏀矾锛屾í鍚戠敾鍥撅級
- int numX2 = node3.getCellNumX();
- int numY2 = node3.getCellNumY();
- // 2.3 璁＄畻绗笁琛�
- int numX3 = node4.getCellNumX() + node5.getCellNumX();
- int numY3 = node4.getCellNumY() > node5.getCellNumY() ? node4.getCellNumY() : node5.getCellNumY();
- numX = Math.max(Math.max(numX1, numX2), numX3);
- numY = numY1 + numY2 + numY3;
- // 2.4 鍔犱笂connect鐨勫ぇ灏�
- numX += LAYOUT_CELL_NUM_CONNECT_X;
- numX += vnode.getCellNumX();
- }
- vnode.setVnodeCellNumX(numX);
- vnode.setVnodeCellNumY(numY);
- }
}
--
Gitblit v1.9.1