From dea248c9da9f82e4032b6ab4a8ce0a6422a5c2cc Mon Sep 17 00:00:00 2001
From: xyc <jc_xiong@hotmail.com>
Date: 星期五, 13 九月 2024 16:35:44 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java | 807 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 727 insertions(+), 80 deletions(-)
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 9836118..9c74487 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,5 +1,6 @@
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;
@@ -11,20 +12,17 @@
import com.zt.life.modules.mainPart.basicInfo.model.ProductImg;
import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
import com.zt.life.modules.mainPart.taskReliability.dao.*;
-import com.zt.life.modules.mainPart.taskReliability.dto.ModelLinePair;
+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.dom4j.DocumentHelper;
-import org.dom4j.Document;
import org.dom4j.Element;
-import org.dom4j.io.OutputFormat;
-import org.dom4j.io.XMLWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zt.common.db.query.QueryFilter;
import org.springframework.transaction.annotation.Transactional;
-import java.io.StringWriter;
import java.util.*;
import java.util.stream.Collectors;
@@ -32,11 +30,47 @@
/**
* model_line
*
- * @author zt generator
+ * @author zt generator
* @since 1.0.0 2024-02-28
*/
@Service
-public class ModelLineService extends BaseService<ModelLineDao, ModelLine> {
+public class ModelLineService extends BaseService<ModelLineDao, ModelLine> {
+ private static final Logger logger = LoggerFactory.getLogger(ModelLineService.class);
+
+ // 杩愮畻
+ public static final String OPE_TYPE_SERIES = "series";
+ public static final String OPE_TYPE_PARALLEL = "parallel";
+ 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;
@Autowired
@@ -77,8 +111,8 @@
@Transactional(rollbackFor = Exception.class)
public void insert(ModelRbd modelRbd) {
- if (modelRbd==null) return;
- if (modelRbd.getId()==null) return;
+ if (modelRbd == null) return;
+ if (modelRbd.getId() == null) return;
Long modelId = modelRbd.getId();
// 鍒犻櫎鏃㈡湁鏁版嵁
@@ -92,8 +126,8 @@
@Transactional(rollbackFor = Exception.class)
public void update(ModelRbd modelRbd) {
- if (modelRbd==null) return;
- if (modelRbd.getId()==null) return;
+ if (modelRbd == null) return;
+ if (modelRbd.getId() == null) return;
Long modelId = modelRbd.getId();
// 鍒犻櫎鏃㈡湁鏁版嵁
@@ -102,10 +136,600 @@
modelRbdDao.insert(modelRbd);
}
+ // 鑷姩鎺掔増RBD
+ @Transactional(rollbackFor = Exception.class)
+ public boolean layout(ModelRbd modelRbd) {
+ boolean result = true;
+ if (modelRbd == null) return result;
+ Long modelId = modelRbd.getId();
+ result = layoutRbd(modelRbd);
+ return result;
+ }
+
+ private boolean layoutRbd(ModelRbd modelRbd) {
+ boolean result = true;
+ String rbdsonStr = modelRbd.getContent();
+
+ JSONArray rbdJsonArray = new JSONObject(rbdsonStr).getJSONArray("cells");
+ if (rbdJsonArray == null) return result;
+
+ // 瑙ｆ瀽缁撴灉瀛樻斁list
+ List<ModelNode> modelNodeList = new ArrayList<>();
+ List<ModelLine> modelLineList = new ArrayList<>();
+ List<Algorithm> algorithmList = new ArrayList<>();
+ List<ProductImg> productImgList = new ArrayList<>(); // 鏆備笉浣跨敤锛堣�屼娇鐢ㄦ暟鎹簱涓殑鍙潬鎬у弬鏁帮級
+
+ // 1. 瑙ｆ瀽鍑鸿妭鐐逛笌杈�
+ getNodeAndLineFromRbd(modelRbd.getId(), rbdJsonArray, modelNodeList, modelLineList, productImgList);
+ // 2. 瀵逛簬鏈夊鏍瑰叆鍙ｇ嚎鐨勪骇鍝佽妭鐐癸紝灏嗗叾涓婄殑琛ㄥ喅銆佹梺鑱斿叧绯诲墺绂绘垚杩愮畻绗﹁妭鐐癸紝娣诲姞鍒拌鑺傜偣鐨勫墠闈紝骞舵坊鍔犵浉搴旂殑杈�
+ peelOperationFromProductNode(modelRbd.getId(), modelNodeList, modelLineList);
+ // 3. 璁＄畻鎵�鏈夎妭鐐圭殑鍏ュ彛绾挎暟鍙婂嚭鍙ｇ嚎鏁�
+ calcInOutLineNumAllNode(modelNodeList, modelLineList);
+ // 4. 澶嶅埗浜у搧鑺傜偣(node)鍒發ist
+ List<ModelNode> modelNodeAndVnodeList = modelNodeList.stream().filter(item ->
+ "node".equals(item.getNodeType())).collect(Collectors.toList());
+ // 5. 涓嶆柇灏嗗熀鏈ā鍨嬶紙涓茶仈銆佸苟鑱斻�佹梺鑱斻�佽〃鍐炽�佹ˉ鑱旓級鏇挎崲涓鸿櫄鑺傜偣鑰岀畝鍖栧浘褰紝鐩磋嚦鏃犳硶绠�鍖栦负姝€��
+ 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);
+
+ RbdTreeNode root = new RbdTreeNode();
+
+ root.setId(Convert.toLong("20000"));
+
+ root.setName("end");
+ root.setNodeType("vnode");
+ root.setAlgorithmType("parallel");
+ root.setPicId("20000");
+ root.setPairStartNodeId("10000");
+
+ root.setBlockWidthNum(root2.getBlockWidthNum() + 2);
+ root.setBlockHeightNum(root2.getBlockHeightNum());
+ root.getChildren().add(root2);
+
+ // 7. 閫掑綊璁＄畻RBD鐨勫竷灞�绌洪棿鍙傛暟锛坸銆亂鍧愭爣锛�
+ root.setBlockX(0);
+ root.setBlockY(0);
+ calcPosition(rbdJsonArray, root);
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("cells", rbdJsonArray);
+ modelRbd.setContent(jsonObject.toString());
+ // calcLayoutPosition(modelRbd, algorithmList, modelNodeAndVnodeList);
+
+ // 8. 淇濆瓨鑷姩甯冨眬妯″瀷
+ // 鏇存柊RBD鏁版嵁
+// modelRbd.setAutoLayoutContent("娴嬭瘯鏂囧瓧");
+// modelRbdDao.updateById(modelRbd);
+
+ return result;
+ }
+
+ private void setNodePositionXY(JSONArray rbdJsonArray, RbdTreeNode block) {
+ Double x = block.getBlockX() + (block.getBlockWidth() - block.getMyWidth()) / 2;
+ Double y = block.getBlockY() + (block.getBlockHeight() - block.getMyHeight()) / 2;
+ setRbdNodePosition(rbdJsonArray, block.getPicId(), x, y);
+ }
+
+ private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block) {
+ if (block.getNodeType().equals("node")) {
+ setNodePositionXY(rbdJsonArray, block);
+ } else {
+ double blockWidth = block.getBlockWidthNum() * LAYOUT_CELL_SIZE_X;
+ double blockHeight = block.getBlockHeightNum() * LAYOUT_CELL_SIZE_Y;
+
+ Double descentWidth = block.getDescentWidth();
+ if (descentWidth == null || descentWidth == 0.0) {
+ descentWidth = blockWidth;
+ }
+ Double descentHeight = block.getDescentHeight();
+ if (descentHeight == null || descentHeight == 0.0) {
+ descentHeight = blockHeight;
+ }
+
+ block.setBlockWidth(blockWidth);
+ block.setBlockHeight(blockHeight);
+ List<RbdTreeNode> children = block.getChildren();
+
+ if (OPE_TYPE_SERIES.equals(block.getAlgorithmType())) {
+ Double subBlockX = block.getBlockX();
+ for (RbdTreeNode child : children) {
+
+ child.setDescentWidth(blockWidth);
+ child.setDescentHeight(blockHeight);
+
+ double selfWidth = child.getBlockWidthNum() * LAYOUT_CELL_SIZE_X * descentWidth / blockWidth;
+ child.setBlockWidth(selfWidth);
+ child.setBlockHeight(blockHeight);
+
+ child.setBlockY(block.getBlockY());
+ child.setBlockX(subBlockX);
+ calcPosition(rbdJsonArray, child);
+ subBlockX = subBlockX + selfWidth;
+
+ }
+ } else {
+
+ Double subBlockY = block.getBlockY()+(descentHeight-blockHeight)/2;
+ Double firstSubBlockY = subBlockY;
+
+ // 璁剧疆connect鐨勪綅缃�
+ RbdTreeNode connectBlock = new RbdTreeNode();
+ connectBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/width"));
+ connectBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPairStartNodeId(), "size/height"));
+ connectBlock.setPicId(block.getPairStartNodeId());
+ connectBlock.setBlockX(block.getBlockX());
+ connectBlock.setBlockY(firstSubBlockY);
+ connectBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
+ connectBlock.setBlockHeight(blockHeight);
+ setNodePositionXY(rbdJsonArray, connectBlock);
+
+ for (RbdTreeNode child : children) {
+ child.setDescentWidth(block.getBlockWidth() - 2 * LAYOUT_CELL_SIZE_X);
+ child.setDescentHeight(blockHeight);
+
+ child.setBlockWidth(block.getBlockWidth() - 2 * LAYOUT_CELL_SIZE_X);
+ child.setBlockHeight(child.getBlockHeightNum() * LAYOUT_CELL_SIZE_Y);
+
+ child.setBlockX(block.getBlockX() + LAYOUT_CELL_SIZE_X);
+ child.setBlockY(subBlockY);
+ subBlockY = subBlockY + child.getBlockHeightNum() * LAYOUT_CELL_SIZE_Y;
+ calcPosition(rbdJsonArray, child);
+ }
+
+ // 璁剧疆杩愮畻绗︾殑浣嶇疆
+ RbdTreeNode opeBlock = new RbdTreeNode();
+
+ opeBlock.setPicId(block.getPicId());
+ opeBlock.setMyWidth(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/width"));
+ opeBlock.setMyHeight(getRbdNodeInfo(rbdJsonArray, block.getPicId(), "size/height"));
+ opeBlock.setBlockX(block.getBlockX() + blockWidth - LAYOUT_CELL_SIZE_X);
+ opeBlock.setBlockY(firstSubBlockY);
+ opeBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
+ opeBlock.setBlockHeight(blockHeight);
+ setNodePositionXY(rbdJsonArray, opeBlock);
+ }
+ }
+
+ }
+
+ 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);
+ }
+
@Transactional(rollbackFor = Exception.class)
public boolean analyze(ModelRbd modelRbd) {
boolean result = true;
- if (modelRbd==null) return result;
+ if (modelRbd == null) return result;
Long modelId = modelRbd.getId();
result = analyzeRbd(modelRbd, true);
return result;
@@ -138,7 +762,7 @@
// 6. 杞崲涓虹畻娉曞簱鎺ュ彛XML
if (result) {
-// result = createIfXmlFromRbd(modelRbd, algorithmList, modelNodeAndVnodeList);
+// result = createIfXmlFromRbd(modelRbd, algorithmList, modelNodeAndVnodeList);
}
// 7. 淇濆瓨妯″瀷
@@ -152,14 +776,14 @@
List<ModelLine> modelLineList) {
List<ModelNode> nodesToAdd = new ArrayList<>();
List<ModelLine> linesToAdd = new ArrayList<>();
- for (ModelNode node: modelNodeList) {
+ for (ModelNode node : modelNodeList) {
List<ModelLine> inLineList = modelLineList.stream().filter(item ->
item.getEndCell().equals(node.getPicId())).collect(Collectors.toList());
if ("node".equals(node.getNodeType()) &&
StringUtils.isNotBlank(node.getNodeTypeExt()) &&
inLineList.size() > 1) {
// 鏃佽仈or琛ㄥ喅
- ModelNode nodeNew = new ModelNode();
+ ModelNode nodeNew = new ModelNode();
Long nodeNewId = UUIDUtil.generateId();
nodeNew.setId(nodeNewId);
nodeNew.setPicId(nodeNewId.toString());
@@ -180,7 +804,7 @@
lineNew.setEndCell(node.getPicId());
linesToAdd.add(lineNew);
- for(ModelLine line: inLineList){
+ for (ModelLine line : inLineList) {
line.setEndCell(nodeNewId.toString());
}
}
@@ -230,19 +854,19 @@
List<ModelNode> modelNodeAndVnodeList) {
ModelNode endNode = modelNodeList.stream().filter(item ->
"end".equals(item.getNodeType())).collect(Collectors.toList()).get(0);
- if (endNode.getInLineNum()!=1) return false;
+ if (endNode.getInLineNum() != 1) return false;
ModelLine lineToEnd = modelLineList.stream().filter(item ->
item.getEndCell().equals(endNode.getPicId())).collect(Collectors.toList()).get(0);
ModelNode node = modelNodeList.stream().filter(item ->
lineToEnd.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
- if (node.getInLineNum()!=1 || node.getOutLineNum()!=1) return false;
+ if (node.getInLineNum() != 1 || node.getOutLineNum() != 1) return false;
ModelLine lineToNode = modelLineList.stream().filter(item ->
item.getEndCell().equals(node.getPicId())).collect(Collectors.toList()).get(0);
ModelNode startNode = modelNodeList.stream().filter(item ->
lineToNode.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
- if (!"start".equals(startNode.getNodeType()) || startNode.getOutLineNum()!=1) return false;
+ if (!"start".equals(startNode.getNodeType()) || startNode.getOutLineNum() != 1) return false;
// 鍒犻櫎鑺傜偣鍙婅繛绾�
modelLineList.remove(lineToEnd);
@@ -262,7 +886,7 @@
algorithm.setAlgorithmType(endNode.getNodeType());
algorithm.setComputerList(node.getId().toString());
algorithm.setObjectList(node.getName());
- algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
+ algorithm.setStep(algorithmList.size() == 0 ? 0 : algorithmList.get(algorithmList.size() - 1).getStep() + 1);
algorithmList.add(algorithm);
// 鏂板缁撴潫鐨勮櫄鑺傜偣
@@ -271,7 +895,7 @@
vnode.setPicId(id.toString());
vnode.setModelId(modelId);
vnode.setNodeType("vnode");
- vnode.setName("v"+algorithm.getStep());
+ vnode.setName("v" + algorithm.getStep());
modelNodeAndVnodeList.add(vnode);
return true;
@@ -285,27 +909,27 @@
boolean hasSimplified) {
List<ModelNode> startNodes = modelNodeList.stream().filter(item ->
"node,vnode,connect,end".contains(item.getNodeType())).collect(Collectors.toList());
- if (startNodes.size()==0) return hasSimplified;
+ if (startNodes.size() == 0) return hasSimplified;
for (ModelNode startNode : startNodes) {
- if (startNode.getInLineNum()!=1) continue;
+ if (startNode.getInLineNum() != 1) continue;
List<ModelNode> result = new ArrayList<>();
if (!"end".equals(startNode.getNodeType())) result.add(startNode);
seekPathSeries(modelNodeList, modelLineList, startNode, result);
- if (result.size()<2) continue;
+ if (result.size() < 2) continue;
- ModelNode endNode = result.get(result.size()-1);
- if ("start,parallel,switch,vote,bridge".contains(endNode.getNodeType()) || endNode.getOutLineNum()!=1) {
+ ModelNode endNode = result.get(result.size() - 1);
+ if ("start,parallel,switch,vote,bridge".contains(endNode.getNodeType()) || endNode.getOutLineNum() != 1) {
result.remove(endNode);
}
List<ModelNode> realSeriesNodes = result.stream().filter(item ->
!"connect".equals(item.getNodeType())).collect(Collectors.toList());
- if (realSeriesNodes.size()<1) {
+ if (realSeriesNodes.size() < 1) {
if (result.size() < 2) continue;
// 鏇挎崲鎴愯繛绾�
replaceToLineSeries(modelNodeList, modelLineList, result);
- } else if (realSeriesNodes.size()==1) {
+ } else if (realSeriesNodes.size() == 1) {
if (result.size() < 2) continue; // path涓婂彧鏈夎浜у搧鑺傜偣锛坣ode/vnode锛夎嚜宸憋紝鏃犻渶鍋氫粈涔�
// 灏唒ath鏇挎崲鎴愯鑺傜偣
replaceToTheNodeSeries(modelNodeList, modelLineList,
@@ -326,12 +950,12 @@
List<ModelNode> path) {
// 鑾峰彇path鐨勮捣鐐圭殑鍑哄彛绾�
ModelNode finalNodeStart = path.get(0);
- ModelNode finalNodeEnd = path.get(path.size()-1);
+ ModelNode finalNodeEnd = path.get(path.size() - 1);
List<ModelLine> outLines = modelLineList.stream().filter(item ->
item.getBeginCell().equals(finalNodeStart.getPicId())).collect(Collectors.toList());
// 鍒犻櫎path涓婄殑鎵�鏈変腑闂磋繛绾垮強path鐨勭粨鏉熺偣浠ュ鐨勮妭鐐�
- for (int i=0; i<path.size(); i++) {
+ for (int i = 0; i < path.size(); i++) {
ModelNode finalNode = path.get(i);
if (i < path.size() - 1) {
// 灏嗗叆鍙ｇ嚎鍒犻櫎
@@ -354,20 +978,20 @@
}
private void replaceToTheNodeSeries(List<ModelNode> modelNodeList,
- List<ModelLine> modelLineList,
- List<ModelNode> path,
- ModelNode theNode) {
+ List<ModelLine> modelLineList,
+ List<ModelNode> path,
+ ModelNode theNode) {
// 鑾峰彇path鐨勮捣鐐圭殑鍑哄彛绾�
ModelNode finalNodeStart = path.get(0);
List<ModelLine> outLines = modelLineList.stream().filter(item ->
item.getBeginCell().equals(finalNodeStart.getPicId())).collect(Collectors.toList());
// 鑾峰彇path鐨勭粨鏉熺偣鐨勫叆鍙ｇ嚎
- ModelNode finalNodeEnd = path.get(path.size()-1);
+ ModelNode finalNodeEnd = path.get(path.size() - 1);
List<ModelLine> inLines = modelLineList.stream().filter(item ->
item.getEndCell().equals(finalNodeEnd.getPicId())).collect(Collectors.toList());
// 鍒犻櫎path涓婄殑鎵�鏈変腑闂磋繛绾垮強theNode浠ュ鐨勮妭鐐�
- for (int i=0; i<path.size(); i++) {
+ for (int i = 0; i < path.size(); i++) {
ModelNode finalNode = path.get(i);
if (i < path.size() - 1) {
// 灏嗗叆鍙ｇ嚎鍒犻櫎
@@ -413,7 +1037,7 @@
algorithm.setAlgorithmType("series");
algorithm.setComputerList(computerList.get(0));
algorithm.setObjectList(computerList.get(1));
- algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
+ algorithm.setStep(algorithmList.size() == 0 ? 0 : algorithmList.get(algorithmList.size() - 1).getStep() + 1);
algorithmList.add(algorithm);
// 鏂板铏氳妭鐐�
@@ -422,16 +1046,16 @@
vnode.setPicId(id.toString());
vnode.setModelId(modelId);
vnode.setNodeType("vnode");
- vnode.setName("v"+algorithm.getStep());
+ vnode.setName("v" + algorithm.getStep());
vnode.setPositionX(path.get(0).getPositionX());
vnode.setPositionY(path.get(0).getPositionY());
modelNodeList.add(vnode);
modelNodeAndVnodeList.add(vnode);
// 灏唒ath鏇挎崲涓鸿铏氳妭鐐�
- for (int i=0; i<path.size(); i++) {
+ for (int i = 0; i < path.size(); i++) {
ModelNode finalNode = path.get(i);
- if (i==0) {
+ if (i == 0) {
// 灏嗚鑺傜偣鐨勫嚭鍙ｇ嚎鏀逛负杩炴帴鍒拌櫄鑺傜偣
List<ModelLine> outLines = modelLineList.stream().filter(item ->
item.getBeginCell().equals(finalNode.getPicId())).collect(Collectors.toList());
@@ -443,7 +1067,7 @@
item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
modelLineList.removeAll(inLines);
}
- if (i==path.size()-1) {
+ if (i == path.size() - 1) {
// 灏嗚鑺傜偣鐨勫叆鍙ｇ嚎鏀逛负杩炴帴鍒拌櫄鑺傜偣
List<ModelLine> inLines = modelLineList.stream().filter(item ->
item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
@@ -563,10 +1187,10 @@
if (isBridgeUpperLine(inLine, modelLineList) || isBridgeLowerLine(inLine, modelLineList)) return;
List<ModelNode> nodes = modelNodeList.stream().filter(item ->
inLine.getBeginCell().equals(item.getPicId())).collect(Collectors.toList());
- if (0==nodes.size()) return; // 鍒版ˉ鑱斾腑闂磋妭鐐圭殑绾跨殑璧风偣涓嶆槸Node锛岃�屾槸Line锛屾墍浠ヨ幏鍙栫殑璧风偣鏁板彲鑳戒负0
+ if (0 == nodes.size()) return; // 鍒版ˉ鑱斾腑闂磋妭鐐圭殑绾跨殑璧风偣涓嶆槸Node锛岃�屾槸Line锛屾墍浠ヨ幏鍙栫殑璧风偣鏁板彲鑳戒负0
ModelNode pathNode = nodes.get(0);
result.add(pathNode);
- if (pathNode.getOutLineNum()!=1 || pathNode.getInLineNum()!=1) return;
+ if (pathNode.getOutLineNum() != 1 || pathNode.getInLineNum() != 1) return;
if ("parallel,switch,vote,bridge".contains(pathNode.getNodeType())) return;
seekPathSeries(modelNodeList, modelLineList, pathNode, result);
}
@@ -602,10 +1226,10 @@
boolean hasSimplifiedMe = false;
List<ModelNode> startNodes = modelNodeList.stream().filter(item ->
"node,vnode,connect,end".contains(item.getNodeType())).collect(Collectors.toList());
- if (startNodes.size()==0) return hasSimplified;
+ if (startNodes.size() == 0) return hasSimplified;
for (ModelNode startNode : startNodes) {
- if (startNode.getInLineNum()<2) continue;
+ if (startNode.getInLineNum() < 2) continue;
List<ModelLine> inLines = modelLineList.stream().filter(item ->
item.getEndCell().equals(startNode.getPicId())).collect(Collectors.toList());
hasSimplifiedMe = simplifyParallelGroup(modelId, modelNodeList, modelLineList,
@@ -619,12 +1243,12 @@
}
private boolean simplifyParallelGroup(Long modelId,
- List<ModelNode> modelNodeList,
- List<ModelLine> modelLineList,
- List<Algorithm> algorithmList,
- List<ModelNode> modelNodeAndVnodeList,
- ModelNode startNode,
- List<ModelLine> lines) {
+ List<ModelNode> modelNodeList,
+ List<ModelLine> modelLineList,
+ List<Algorithm> algorithmList,
+ List<ModelNode> modelNodeAndVnodeList,
+ ModelNode startNode,
+ List<ModelLine> lines) {
boolean hasSimplified = false;
List<List<ModelNode>> pathList = new ArrayList<>();
for (ModelLine line : lines) {
@@ -634,10 +1258,10 @@
Map<ModelNode, List<List<ModelNode>>> endNodePathsMap = groupingPathByEndNode(pathList);
for (Map.Entry<ModelNode, List<List<ModelNode>>> entry : endNodePathsMap.entrySet()) {
List<List<ModelNode>> pathOneGroup = entry.getValue();
- if (pathOneGroup.size()>1) {
+ if (pathOneGroup.size() > 1) {
List<ModelNode> branchNodeList = new ArrayList<>();
ModelNode endNode = getBranchNodesOneParallel(pathOneGroup, branchNodeList);
- if ("connect".equals(startNode.getNodeType()) && pathOneGroup.size()==lines.size()) {
+ if ("connect".equals(startNode.getNodeType()) && pathOneGroup.size() == lines.size()) {
// 鏇挎崲鎴愯櫄鑺傜偣
modelNodeAndVnodeList.add(startNode);
replaceToVnode("parallel", modelId, modelNodeList, modelLineList,
@@ -686,7 +1310,7 @@
item.getEndCell().equals(branchNode.getPicId())).collect(Collectors.toList());
List<ModelLine> outLines = modelLineList.stream().filter(item ->
item.getBeginCell().equals(branchNode.getPicId())).collect(Collectors.toList());
- if (inLines.size()!=1 || outLines.size()!=1) return path;
+ if (inLines.size() != 1 || outLines.size() != 1) return path;
ModelLine lineToBranchNode = inLines.get(0);
ModelNode endNode = modelNodeList.stream().filter(item ->
lineToBranchNode.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
@@ -699,7 +1323,7 @@
private Map<ModelNode, List<List<ModelNode>>> groupingPathByEndNode(List<List<ModelNode>> pathList) {
Map<ModelNode, List<List<ModelNode>>> endNodePathsMap = new HashMap<>();
for (List<ModelNode> path : pathList) {
- ModelNode endNode = path.get(path.size()-1);
+ ModelNode endNode = path.get(path.size() - 1);
if (endNodePathsMap.containsKey(endNode)) {
endNodePathsMap.get(endNode).add(path);
} else {
@@ -712,11 +1336,11 @@
}
private ModelNode getBranchNodesOneParallel(List<List<ModelNode>> paths,
- List<ModelNode> branchNodeList) {
+ List<ModelNode> branchNodeList) {
ModelNode endNode = null;
for (List<ModelNode> path : paths) {
branchNodeList.add(path.get(0));
- endNode = path.get(path.size()-1);
+ endNode = path.get(path.size() - 1);
}
return endNode;
}
@@ -730,14 +1354,14 @@
boolean hasSimplifiedMe = false;
List<ModelNode> startNodes = modelNodeList.stream().filter(item ->
"bridge".equals(item.getNodeType())).collect(Collectors.toList());
- if (startNodes.size()==0) return hasSimplified;
+ if (startNodes.size() == 0) return hasSimplified;
for (ModelNode startNode : startNodes) {
List<ModelLine> lines = modelLineList.stream().filter(item ->
item.getEndCell().equals(startNode.getPicId())).collect(Collectors.toList());
- if (lines.size()<2) continue;
- List<ModelLinePair> linePairs = getLinePairs(lines);
- for (ModelLinePair linePair : linePairs) {
+ if (lines.size() < 2) continue;
+ List<ModelLinePairDto> linePairs = getLinePairs(lines);
+ for (ModelLinePairDto linePair : linePairs) {
hasSimplifiedMe = simplifyBridgeOneLinePair(modelId, modelNodeList, modelLineList,
algorithmList, modelNodeAndVnodeList, startNode, linePair);
if (hasSimplifiedMe) {
@@ -756,7 +1380,7 @@
List<Algorithm> algorithmList,
List<ModelNode> modelNodeAndVnodeList,
ModelNode startNode,
- ModelLinePair linePair) {
+ ModelLinePairDto linePair) {
ModelNode node1 = null;
ModelNode node2 = null;
ModelNode node3 = null;
@@ -834,8 +1458,8 @@
linePair.getLine1().getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
ModelNode nodeTmp2 = modelNodeList.stream().filter(item ->
linePair.getLine2().getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
- if (nodeTmp1.getInLineNum()!=1 || nodeTmp1.getOutLineNum()!=1) return false;
- if (nodeTmp2.getInLineNum()!=1 || nodeTmp2.getOutLineNum()!=1) return false;
+ if (nodeTmp1.getInLineNum() != 1 || nodeTmp1.getOutLineNum() != 1) return false;
+ if (nodeTmp2.getInLineNum() != 1 || nodeTmp2.getOutLineNum() != 1) return false;
ModelNode finalNode = nodeTmp1;
ModelLine lineToNodeTmp1 = modelLineList.stream().filter(item ->
item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList()).get(0);
@@ -880,15 +1504,15 @@
finalLine3.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
if (!node3Candidate1.getId().equals(node3Candidate2.getId())) return false;
node3 = node3Candidate1;
- if (node3.getInLineNum()!=1 || node3.getOutLineNum()!=1) return false;
+ if (node3.getInLineNum() != 1 || node3.getOutLineNum() != 1) return false;
ModelLine finalLine4 = line1To2;
node1 = modelNodeList.stream().filter(item ->
finalLine4.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
- if (node1.getInLineNum()!=1 || node1.getOutLineNum()!=1) return false;
+ if (node1.getInLineNum() != 1 || node1.getOutLineNum() != 1) return false;
ModelLine finalLine5 = line4To5;
node4 = modelNodeList.stream().filter(item ->
finalLine5.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
- if (node4.getInLineNum()!=1 || node4.getOutLineNum()!=1) return false;
+ if (node4.getInLineNum() != 1 || node4.getOutLineNum() != 1) return false;
ModelNode finalNode3 = node1;
ModelLine lineTo1 = modelLineList.stream().filter(item ->
item.getEndCell().equals(finalNode3.getPicId())).collect(Collectors.toList()).get(0);
@@ -967,11 +1591,11 @@
}
// 鎵惧嚭鎵�鏈�2鏍圭嚎鐨勭粍鍚�
- private List<ModelLinePair> getLinePairs(List<ModelLine> lines) {
- List<ModelLinePair> linePairs = new ArrayList<>();
- for (int i=0; i<lines.size()-1; i++) {
- for (int j=i+1; j<lines.size(); j++) {
- ModelLinePair linePair = new ModelLinePair();
+ private List<ModelLinePairDto> getLinePairs(List<ModelLine> lines) {
+ List<ModelLinePairDto> linePairs = new ArrayList<>();
+ for (int i = 0; i < lines.size() - 1; i++) {
+ for (int j = i + 1; j < lines.size(); j++) {
+ ModelLinePairDto linePair = new ModelLinePairDto();
linePair.setLine1(lines.get(i));
linePair.setLine2(lines.get(j));
linePairs.add(linePair);
@@ -989,7 +1613,7 @@
boolean hasSimplified) {
List<ModelNode> opNodes = modelNodeList.stream().filter(item ->
operator.equals(item.getNodeType())).collect(Collectors.toList());
- if (opNodes.size()==0) return hasSimplified;
+ if (opNodes.size() == 0) return hasSimplified;
for (ModelNode opNode : opNodes) {
List<ModelLine> lines = modelLineList.stream().filter(item ->
@@ -1044,7 +1668,7 @@
algorithm.setComputerList(computerList.get(0));
algorithm.setObjectList(computerList.get(1));
if ("vote".equals(type)) algorithm.setVoteNum(startNode.getVoteNum());
- algorithm.setStep(algorithmList.size()==0 ? 0 : algorithmList.get(algorithmList.size()-1).getStep()+1);
+ algorithm.setStep(algorithmList.size() == 0 ? 0 : algorithmList.get(algorithmList.size() - 1).getStep() + 1);
algorithmList.add(algorithm);
// 鏇挎崲涓鸿櫄鑺傜偣
@@ -1058,7 +1682,7 @@
}
startNode.setId(id);
startNode.setNodeType("vnode");
- startNode.setName("v"+algorithm.getStep());
+ startNode.setName("v" + algorithm.getStep());
ModelLine modelLineNew = new ModelLine();
Long picId2 = UUIDUtil.generateId();
@@ -1077,14 +1701,14 @@
List<ModelLine> modelLineList,
ModelLine line,
List<ModelNode> branchNodeList
- ) {
+ ) {
ModelNode branchNode = modelNodeList.stream().filter(item ->
line.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
List<ModelLine> inLines = modelLineList.stream().filter(item ->
item.getEndCell().equals(branchNode.getPicId())).collect(Collectors.toList());
List<ModelLine> outLines = modelLineList.stream().filter(item ->
item.getBeginCell().equals(branchNode.getPicId())).collect(Collectors.toList());
- if (inLines.size()!=1 || outLines.size()!=1) return null;
+ if (inLines.size() != 1 || outLines.size() != 1) return null;
ModelLine lineToBranchNode = inLines.get(0);
ModelNode endNode = modelNodeList.stream().filter(item ->
lineToBranchNode.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
@@ -1110,7 +1734,7 @@
modelLine.setBeginCell(JsonUtils2.getJsonValueByPath(jsonObject, "source/cell".split("/")).toString());
modelLine.setEndCell(JsonUtils2.getJsonValueByPath(jsonObject, "target/cell".split("/")).toString());
modelLineList.add(modelLine);
- } else if ("image".equals(shape)){
+ } else if ("image".equals(shape)) {
ModelNode modelNode = new ModelNode();
modelNode.setId(UUIDUtil.generateId());
modelNode.setModelId(modelId);
@@ -1118,9 +1742,19 @@
modelNode.setNodeType(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeType".split("/")).toString());
modelNode.setPositionX(Double.valueOf(JsonUtils2.getJsonValueByPath(jsonObject, "position/x".split("/")).toString()));
modelNode.setPositionY(Double.valueOf(JsonUtils2.getJsonValueByPath(jsonObject, "position/y".split("/")).toString()));
+ modelNode.setWidth(new Double(JsonUtils2.getJsonValueByPath(jsonObject, "size/width".split("/")).toString()));
+ modelNode.setHeight(new Double(JsonUtils2.getJsonValueByPath(jsonObject, "size/height".split("/")).toString()));
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/voteNum".split("/"));
- if (jsonValue!=null && StringUtils.isNotBlank(jsonValue.toString())) {
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
modelNode.setVoteNum(Integer.valueOf(jsonValue.toString()));
+ }
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/startNodeId".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ modelNode.setPairStartNodeId(jsonValue.toString());
+ }
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/endNodeId".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ modelNode.setPairEndNodeId(jsonValue.toString());
}
if ("node".equals(modelNode.getNodeType())) {
ProductImg productImg = new ProductImg();
@@ -1128,7 +1762,7 @@
modelNode.setDataId(Long.valueOf(dataId));
modelNode.setNodeTypeExt(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeTypeExt".split("/")).toString());
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "attrs/text/text".split("/"));
- modelNode.setName(jsonValue==null ? "" : jsonValue.toString());
+ modelNode.setName(jsonValue == null ? "" : jsonValue.toString());
productImg.setDataId(dataId);
String productType = JsonUtils2.getJsonValueByPath(jsonObject, "data/productType".split("/")).toString();
@@ -1137,6 +1771,19 @@
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/reliabDistribType".split("/"));
if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
productImg.setReliabDistribType(Integer.valueOf(jsonValue.toString()));
+ if (3 == productImg.getReliabDistribType()) {
+ // 浜岄」鍒嗗竷
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/simulatTimes".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ productImg.setBinomialTotalNum(Integer.valueOf(jsonValue.toString()));
+ modelNode.setBinomialTotalNum(Integer.valueOf(jsonValue.toString()));
+ }
+ jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/successTimes".split("/"));
+ if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
+ productImg.setBinomialSuccessNum(Integer.valueOf(jsonValue.toString()));
+ modelNode.setBinomialSuccessNum(Integer.valueOf(jsonValue.toString()));
+ }
+ }
}
jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcf".split("/"));
if (null != jsonValue) productImg.setTaskMtbcf(jsonValue.toString());
--
Gitblit v1.9.1