修改自动排版算法

xyc

2024-10-15 d2112d88bb536f8e08eb3ce123a2b2230c4411f9

 modules/mainPart/src/main/java/com/zt/life/modules/mainPart/taskReliability/service/ModelLineService.java

@@ -7,24 +7,17 @@
import com.zt.common.utils.UUIDUtil;
import com.zt.life.modules.mainPart.basicInfo.dao.ParamDataDao;
import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
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.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 +25,20 @@
/**
 * 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";

    @Autowired
    private ModelLineDao modelLineDao;
    @Autowired
@@ -77,8 +79,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 +94,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,12 +104,644 @@
        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;
    }

    @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;
    }

    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. 转换为树型结构
        RbdTreeNode root = recognizeRbd(modelNodeList, modelLineList);
        // 3. 将桥联转换为3支路的并联
        convertBridgeToThreeBranchParallel(root);
        // 4. 递归计算RBD的布局空间大小
        calcLayoutSize(root);

        // 5. 递归计算RBD的布局空间参数（x、y坐标）
        root.setBlockX(0);
        root.setBlockY(0);
        Map<String, RbdTreeNode> nodeMap = new HashMap<>();
        calcPosition(rbdJsonArray, root, nodeMap, false);
        setEdgeRouter(rbdJsonArray, nodeMap);

        // 6. 保存自动布局模型
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("cells", rbdJsonArray);
        modelRbd.setContent(jsonObject.toString());
        modelRbdDao.updateById(modelRbd);

        return result;
    }

    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 {

            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) {

                    double selfBlockWidth = child.getBlockWidth() * descentWidth / block.getBlockWidth();
                    child.setDescentWidth(selfBlockWidth);
                    child.setBlockWidth(selfBlockWidth);
                    if (lastIsSeries)
                        child.setDescentHeight(descentHeight);
                    else
                        child.setDescentHeight(block.getBlockHeight());

                    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());

                    if (!"vnode".equals(child.getNodeType())) {
                        child.setBlockWidth(block.getBlockWidth());
                    }

                    child.setBlockX(block.getBlockX());
                    child.setBlockY(subBlockY);
                    calcPosition(rbdJsonArray, child, nodeMap, false);
                    subBlockY = subBlockY + child.getBlockHeight();
                }
            }
        }
    }

    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);
    }

    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 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,
                                       JSONArray rbdJsonArray,
                                       List<ModelNode> modelNodeList,
                                       List<ModelLine> modelLineList,
                                       List<ProductImg> productImgList) {
        Object jsonValue = null;
        for (int i = 0; i < rbdJsonArray.size(); i++) {
            JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
            String shape = jsonObject.get("shape").toString();
            if ("edge".equals(shape)) {
                ModelLine modelLine = new ModelLine();
                modelLine.setId(UUIDUtil.generateId());
                modelLine.setModelId(modelId);
                modelLine.setPicId(jsonObject.get("id").toString());
                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)) {
                ModelNode modelNode = new ModelNode();
                modelNode.setId(UUIDUtil.generateId());
                modelNode.setModelId(modelId);
                modelNode.setPicId(jsonObject.get("id").toString());
                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())) {
                    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());
                }
                jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/edgeTopId".split("/"));
                if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
                    modelNode.setBridgeEdgeTopId(jsonValue.toString());
                }
                jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/edgeBottomId".split("/"));
                if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
                    modelNode.setBridgeEdgeBottomId(jsonValue.toString());
                }
                if ("dashedBox".equals(modelNode.getNodeType())) {
                    modelNode.setNodeType("node");
                } else if ("node".equals(modelNode.getNodeType())) {
                    ProductImg productImg = new ProductImg();
                    String dataId = JsonUtils2.getJsonValueByPath(jsonObject, "data/dataId".split("/")).toString();
                    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());

                    productImg.setDataId(dataId);
                    String productType = JsonUtils2.getJsonValueByPath(jsonObject, "data/productType".split("/")).toString();
                    productImg.setProductType(productType);
                    if ("product_sb".equals(productType)) {
                        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());
                        jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcfOtherParams2".split("/"));
                        if (null != jsonValue) productImg.setTaskMtbcfOtherParams2(jsonValue.toString());
                        jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcfOtherParams3".split("/"));
                        if (null != jsonValue) productImg.setTaskMtbcfOtherParams3(jsonValue.toString());
                        jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/isRepair".split("/"));
                        if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString()) && !"null".equals(jsonValue.toString())) {
                            productImg.setIsRepair(Integer.valueOf(jsonValue.toString()));
                        } else {
                            productImg.setIsRepair(0);
                        }
                        if (1 == productImg.getIsRepair()) {
                            jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairDistribType".split("/"));
                            if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
                                productImg.setRepairDistribType(Integer.valueOf(jsonValue.toString()));
                            }
                            jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcr".split("/"));
                            if (null != jsonValue) productImg.setRepairMttcr(jsonValue.toString());
                            jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcrOtherParams2".split("/"));
                            if (null != jsonValue) productImg.setRepairMttcrOtherParams2(jsonValue.toString());
                            jsonValue = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcrOtherParams3".split("/"));
                            if (null != jsonValue) productImg.setRepairMttcrOtherParams3(jsonValue.toString());
                        }
                    }
                    productImgList.add(productImg);
                }
                modelNodeList.add(modelNode);
            }
        }
    }

    private void saveModel(ModelRbd modelRbd,
                           List<Algorithm> algoList,
                           List<ModelNode> modelNodeAndVnodeList) {
        // 删除既有数据
        algorithmDao.deleteByModelId(modelRbd.getId());
        modelNodeAlgorithmDao.deleteByModelId(modelRbd.getId());

        // 插入数据
        for (Algorithm algorithm : algoList) {
            algorithmDao.insert(algorithm);
        }
        for (ModelNode modelNode : modelNodeAndVnodeList) {
            modelNodeAlgorithmDao.insert(ModelNodeAlgorithm.from(modelNode));
        }

        // 更新RBD数据
        modelRbd.setPublishedContent(modelRbd.getContent());
        modelRbdDao.updateById(modelRbd);
    }

    private RbdTreeNode recognizeRbd(List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList) {
        Map<String, Integer> vnodeCounter = new HashMap<>();
        vnodeCounter.put("vnodeCounter", 0);
        RbdTreeNode root = new RbdTreeNode();
        root.setAlgorithmType("series");
        root.setId(UUIDUtil.generateId());
        int counter = vnodeCounter.get("vnodeCounter");
        root.setName("v" + counter);
        counter++;
        vnodeCounter.put("vnodeCounter", counter);
        root.setNodeType("vnode");

        ModelNode end = modelNodeList.stream().filter(item ->
                "end".equals(item.getNodeType())).collect(Collectors.toList()).get(0);
        RbdTreeNode endNode = new RbdTreeNode();
        endNode.setId(end.getId());
        endNode.setName("end");
        endNode.setNodeType("end");
        endNode.setPicId(end.getPicId());
        endNode.setPairStartNodeId(end.getPairStartNodeId());
        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);
        recognizeOneBranch(root,
                lineRight,
                null,
                modelNodeList,
                modelLineList,
                vnodeCounter);

        return root;
    }

    private void recognizeOneBranch(RbdTreeNode parent,
                                    ModelLine lineRight, // 串联的起始线（右边）
                                    ModelLine lineLeft, // 串联的结束线（左边）
                                    List<ModelNode> modelNodeList,
                                    List<ModelLine> modelLineList,
                                    Map<String, Integer> vnodeCounter) {
        ModelLine inLine = lineRight;
        for (; ; ) {
            ModelLine searchLine = inLine;
            ModelNode node = modelNodeList.stream().filter(item ->
                    searchLine.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            if ("node".equals(node.getNodeType())) {
                RbdTreeNode treeNode = new RbdTreeNode();
                treeNode.setId(node.getId());
                treeNode.setName(node.getName());
                treeNode.setNodeType(node.getNodeType());
                treeNode.setPicId(node.getPicId());
                treeNode.setDataId(node.getDataId());
                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);
            } else if ("start".equals(node.getNodeType())) {
                RbdTreeNode treeNode = new RbdTreeNode();
                treeNode.setId(node.getId());
                treeNode.setName(node.getNodeType());
                treeNode.setNodeType(node.getNodeType());
                treeNode.setPicId(node.getPicId());
                treeNode.setObjectWidth(node.getWidth());
                treeNode.setObjectHeight(node.getHeight());
                parent.getChildren().add(treeNode);
                break;
            } else if ("connect".equals(node.getNodeType())) {
                break;
            } else if ("parallel,vote,switch,bridge".contains(node.getNodeType())) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                ModelNode connect = modelNodeList.stream().filter(item ->
                        node.getPairStartNodeId().equals(item.getPicId())).collect(Collectors.toList()).get(0);
                RbdTreeNode treeNode = new RbdTreeNode();
                treeNode.setId(connect.getId());
                treeNode.setName(connect.getNodeType());
                treeNode.setNodeType(connect.getNodeType());
                treeNode.setPicId(connect.getPicId());
                treeNode.setObjectWidth(connect.getWidth());
                treeNode.setObjectHeight(connect.getHeight());
                subNode.getChildren().add(treeNode);
                RbdTreeNode subNodeOpe = new RbdTreeNode();
                subNodeOpe.setAlgorithmType(node.getNodeType());
                subNodeOpe.setId(UUIDUtil.generateId());
                counter = vnodeCounter.get("vnodeCounter");
                subNodeOpe.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNodeOpe.setNodeType("vnode");
                subNodeOpe.setVoteNum(node.getVoteNum());
                subNode.getChildren().add(subNodeOpe);
                treeNode = new RbdTreeNode();
                treeNode.setId(node.getId());
                treeNode.setName(node.getNodeType());
                treeNode.setNodeType(node.getNodeType());
                treeNode.setPicId(node.getPicId());
                treeNode.setPairStartNodeId(node.getPairStartNodeId());
                treeNode.setObjectWidth(node.getWidth());
                treeNode.setObjectHeight(node.getHeight());
                subNode.getChildren().add(treeNode);
                recognizeOpeBlock(subNodeOpe,
                        node,
                        modelNodeList,
                        modelLineList,
                        vnodeCounter);
                inLine = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(connect.getPicId())).collect(Collectors.toList()).get(0);
            }

            if (null != lineLeft) {
                if (inLine.getPicId().equals(lineLeft.getPicId())) break;
            }
        }
        if ("series".equals(parent.getAlgorithmType())) Collections.reverse(parent.getChildren());
    }

    private void recognizeOpeBlock(RbdTreeNode parent,
                                   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 ->
                    item.getEndCell().equals(searchNode.getPicId())).collect(Collectors.toList());
            List<ModelLine> sortedLines = sortLine(lines, modelNodeList);
            for (ModelLine line : sortedLines) {
                boolean isSeries = isSeriesBranch(rightNode, line, modelNodeList, modelLineList);
                if (isSeries) {
                    RbdTreeNode subNode = new RbdTreeNode();
                    subNode.setAlgorithmType("series");
                    subNode.setId(UUIDUtil.generateId());
                    int counter = vnodeCounter.get("vnodeCounter");
                    subNode.setName("v" + counter);
                    counter++;
                    vnodeCounter.put("vnodeCounter", counter);
                    subNode.setNodeType("vnode");
                    parent.getChildren().add(subNode);
                    recognizeOneBranch(subNode, line, null, modelNodeList, modelLineList, vnodeCounter);
                } else {
                    recognizeOneBranch(parent, line, null, modelNodeList, modelLineList, vnodeCounter);
                }
            }
        } else if ("bridge".contains(parent.getAlgorithmType())) {
            ModelNode searchNode = rightNode;
            List<ModelLine> linesRight = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(searchNode.getPicId())).collect(Collectors.toList());
            List<ModelLine> sortedLinesRight = sortLine(linesRight, modelNodeList);
            List<ModelLine> linesLeft = modelLineList.stream().filter(item ->
                    item.getBeginCell().equals(searchNode.getPairStartNodeId())).collect(Collectors.toList());
            List<ModelLine> sortedLinesLeft = sortLine(linesLeft, modelNodeList);
            ModelLine lineTop = modelLineList.stream().filter(item ->
                    item.getPicId().equals(searchNode.getBridgeEdgeTopId())).collect(Collectors.toList()).get(0);
            ModelLine lineBottom = modelLineList.stream().filter(item ->
                    item.getPicId().equals(searchNode.getBridgeEdgeBottomId())).collect(Collectors.toList()).get(0);
            ModelLine verticalLineUpper = modelLineList.stream().filter(item ->
                    item.getBeginCell().equals(searchNode.getBridgeEdgeTopId())).collect(Collectors.toList()).get(0);
            ModelLine verticalLineLower = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(searchNode.getBridgeEdgeBottomId())).collect(Collectors.toList()).get(0);
            // 桥联的第1个支路
            if (isSeriesBranch(lineTop, sortedLinesLeft.get(0), modelNodeList, modelLineList)) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                recognizeOneBranch(subNode, lineTop, sortedLinesLeft.get(0), modelNodeList, modelLineList, vnodeCounter);
            } else {
                recognizeOneBranch(parent, lineTop, sortedLinesLeft.get(0), modelNodeList, modelLineList, vnodeCounter);
            }
            // 桥联的第2个支路
            if (isSeriesBranch(sortedLinesRight.get(0), lineTop, modelNodeList, modelLineList)) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                recognizeOneBranch(subNode, sortedLinesRight.get(0), lineTop, modelNodeList, modelLineList, vnodeCounter);
            } else {
                recognizeOneBranch(parent, sortedLinesRight.get(0), lineTop, modelNodeList, modelLineList, vnodeCounter);
            }
            // 桥联的第3个支路
            if (isSeriesBranch(verticalLineLower, verticalLineUpper, modelNodeList, modelLineList)) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                recognizeOneBranch(subNode, verticalLineLower, verticalLineUpper, modelNodeList, modelLineList, vnodeCounter);
            } else {
                recognizeOneBranch(parent, verticalLineLower, verticalLineUpper, modelNodeList, modelLineList, vnodeCounter);
            }
            // 桥联的第4个支路
            if (isSeriesBranch(lineBottom, sortedLinesLeft.get(1), modelNodeList, modelLineList)) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                recognizeOneBranch(subNode, lineBottom, sortedLinesLeft.get(1), modelNodeList, modelLineList, vnodeCounter);
            } else {
                recognizeOneBranch(parent, lineBottom, sortedLinesLeft.get(1), modelNodeList, modelLineList, vnodeCounter);
            }
            // 桥联的第5个支路
            if (isSeriesBranch(sortedLinesRight.get(1), lineBottom, modelNodeList, modelLineList)) {
                RbdTreeNode subNode = new RbdTreeNode();
                subNode.setAlgorithmType("series");
                subNode.setId(UUIDUtil.generateId());
                int counter = vnodeCounter.get("vnodeCounter");
                subNode.setName("v" + counter);
                counter++;
                vnodeCounter.put("vnodeCounter", counter);
                subNode.setNodeType("vnode");
                parent.getChildren().add(subNode);
                recognizeOneBranch(subNode, sortedLinesRight.get(1), lineBottom, modelNodeList, modelLineList, vnodeCounter);
            } else {
                recognizeOneBranch(parent, sortedLinesRight.get(1), lineBottom, modelNodeList, modelLineList, vnodeCounter);
            }
        }
    }

    /**
     * 按自上而下的顺序排序
     */
    private List<ModelLine> sortLine(List<ModelLine> lines,
                                     List<ModelNode> modelNodeList) {
        for (ModelLine line : lines) {
            ModelNode node = modelNodeList.stream().filter(item ->
                    line.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            line.setBeginY(node.getPositionY());
        }
        lines.sort(Comparator.comparing(ModelLine::getBeginY));

        return lines;
    }

    private boolean isSeriesBranch(ModelNode rightNode, // rbd中的右节点（包括end及4种运算符）
                                   ModelLine line, // 右节点的入口线
                                   List<ModelNode> modelNodeList,
                                   List<ModelLine> modelLineList) {
        boolean result = false;
        ModelNode node = modelNodeList.stream().filter(item ->
                line.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        if ("node".equals(node.getNodeType())) {
            ModelLine line1 = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node.getPicId())).collect(Collectors.toList()).get(0);
            ModelNode node1 = modelNodeList.stream().filter(item ->
                    line1.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            result = !node1.getPicId().equals(rightNode.getPairStartNodeId());
        } else {
            ModelNode node2 = modelNodeList.stream().filter(item ->
                    node.getPairStartNodeId().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            ModelLine line2 = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node2.getPicId())).collect(Collectors.toList()).get(0);
            ModelNode node3 = modelNodeList.stream().filter(item ->
                    line2.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            result = !node3.getPicId().equals(rightNode.getPairStartNodeId());
        }

        return result;
    }

    private boolean isSeriesBranch(ModelLine lineRight, // 串联的起始线（右边）
                                   ModelLine lineLeft, // 串联的结束线（左边）
                                   List<ModelNode> modelNodeList,
                                   List<ModelLine> modelLineList) {
        boolean result = false;
        ModelNode node = modelNodeList.stream().filter(item ->
                lineRight.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        if ("node".equals(node.getNodeType())) {
            ModelLine line1 = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node.getPicId())).collect(Collectors.toList()).get(0);
            result = !line1.getPicId().equals(lineLeft.getPicId());
        } else {
            ModelNode node1 = modelNodeList.stream().filter(item ->
                    node.getPairStartNodeId().equals(item.getPicId())).collect(Collectors.toList()).get(0);
            ModelLine line2 = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node1.getPicId())).collect(Collectors.toList()).get(0);
            result = !line2.getPicId().equals(lineLeft.getPicId());
        }

        return result;
    }

@@ -123,1345 +757,230 @@
        List<ModelLine> modelLineList = new ArrayList<>();
        List<Algorithm> algorithmList = new ArrayList<>();
        List<ProductImg> productImgList = new ArrayList<>();    // 暂不使用（而使用数据库中的可靠性参数）
        List<ModelNode> modelNodeAndVnodeList = new ArrayList<>();

        // 1. 解析出节点与边
        getNodeAndLineFromRbd(modelRbd.getId(), rbdJsonArray, modelNodeList, modelLineList, productImgList);
        // 2. 对于有多根入口线的产品节点，将其上的表决、旁联关系剥离成运算符节点，添加到该节点的前面，并添加相应的边
        peelOperationFromProductNode(modelRbd.getId(), modelNodeList, modelLineList);
        // 3. 计算所有节点的入口线数及出口线数
        calcInOutLineNumAllNode(modelNodeList, modelLineList);
        // 4. 复制产品节点(node)到list
        List<ModelNode> modelNodeAndVnodeList = modelNodeList.stream().filter(item ->
                "node".equals(item.getNodeType())).collect(Collectors.toList());
        // 5. 不断将基本模型（串联、并联、旁联、表决、桥联）替换为虚节点而简化图形，直至无法简化为止。
        result = getAlgorithmFromRbd(modelRbd, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);

        // 6. 转换为算法库接口XML
        if (result) {
            result = createIfXmlFromRbd(modelRbd, algorithmList, modelNodeAndVnodeList);
        }

        // 7. 保存模型
        if (saveFlag) saveModel(modelRbd, modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);
        // 2. 转换为树型结构
        RbdTreeNode root = recognizeRbd(modelNodeList, modelLineList);
        // 3. 预处理
        deleteSeriesForAutoArrange(root);
        deleteStartEnd(root);
        // 3. 生成算法
        createAlgorithm(modelRbd.getId(), root, algorithmList, modelNodeAndVnodeList);
        // 4. 保存模型
        if (saveFlag) saveModel(modelRbd, algorithmList, modelNodeAndVnodeList);

        return result;
    }

    private void peelOperationFromProductNode(Long modelId,
                                              List<ModelNode> modelNodeList,
                                              List<ModelLine> modelLineList) {
        List<ModelNode> nodesToAdd = new ArrayList<>();
        List<ModelLine> linesToAdd = new ArrayList<>();
        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();
                Long nodeNewId = UUIDUtil.generateId();
                nodeNew.setId(nodeNewId);
                nodeNew.setPicId(nodeNewId.toString());
                nodeNew.setModelId(modelId);
                nodeNew.setNodeType(node.getNodeTypeExt());
                nodeNew.setName(node.getNodeTypeExt());
                nodeNew.setVoteNum(node.getVoteNum());
                nodeNew.setPositionX(node.getPositionX());
                nodeNew.setPositionY(node.getPositionY());
                nodesToAdd.add(nodeNew);

                ModelLine lineNew = new ModelLine();
                Long lineNewId = UUIDUtil.generateId();
                lineNew.setId(lineNewId);
                lineNew.setPicId(lineNewId.toString());
                lineNew.setModelId(modelId);
                lineNew.setBeginCell(nodeNewId.toString());
                lineNew.setEndCell(node.getPicId());
                linesToAdd.add(lineNew);

                for(ModelLine line: inLineList){
                    line.setEndCell(nodeNewId.toString());
                }
            }
        }
        modelNodeList.addAll(nodesToAdd);
        modelLineList.addAll(linesToAdd);
    }

    private boolean createIfXmlFromRbd(ModelRbd modelRbd,
                                       List<Algorithm> algorithmList,
                                       List<ModelNode> modelNodeAndVnodeList) {
        boolean result = true;

        try {
            Document document = DocumentHelper.createDocument();
            // 添加root节点
            Element root = document.addElement("DES");
            root.addAttribute("Name", "A System");
            // 添加terminal节点到root1
            Element terminal = root.addElement("Node");
            terminal.addAttribute("Name", "Terminal");
            terminal.addAttribute("Type", "NODE");

            // 将模型转换为DOM，添加到root
            Algorithm endAlgo = algorithmList.stream().filter(item ->
                    "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
            ModelNode computerNode = modelNodeAndVnodeList.stream().filter(item ->
                    endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
            node2DOM(algorithmList, modelNodeAndVnodeList, computerNode, root);

            // 添加start节点到root
            Element start = root.addElement("Node");
            start.addAttribute("Name", "Start");
            start.addAttribute("Type", "NODE");
            // 添加link（路径）到root
            Element link = root.addElement("Link");
            Element block = link.addElement("Block");
            block.addAttribute("Name", "Terminal");
            block = link.addElement("Block");
            block.addAttribute("Name", computerNode.getId().toString());
            block = link.addElement("Block");
            block.addAttribute("Name", "Start");

//            document.setXMLEncoding("UTF-8");
//            String xmlString = document.asXML();
            // 输出格式化xml
            XMLWriter xmlWriter = null;
            try {
                OutputFormat format = OutputFormat.createPrettyPrint();
                format.setEncoding("UTF-8");
                StringWriter writer = new StringWriter();
                xmlWriter = new XMLWriter(writer, format);
                xmlWriter.write(document);
                modelRbd.setPublishedXml(writer.toString());
            } finally {
                if (xmlWriter!=null) xmlWriter.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            result = false;
        }

        return result;
    }

    // 递归函数
    private void node2DOM(List<Algorithm> algorithmList,
                          List<ModelNode> modelNodeAndVnodeList,
                          ModelNode node,
                          Element parent) {
        if ("node".equals(node.getNodeType())) {
            Long dataId = node.getDataId();
            XhProductModel xhProductModel = xhProductModelDao.getById(dataId);
            if (xhProductModel == null) return;
            if ("1".equals(xhProductModel.getProductType())) {
                // 设备
                ParamData paramData = paramDataDao.getParamData(dataId, "expect");
                if (paramData == null) return;
                Element element = parent.addElement("Node");
                element.addAttribute("Name", dataId.toString());
                element.addAttribute("Type", "NODE");
                Element failureTag = element.addElement("Failure");
                failureTag.addAttribute("Dist", "EXP"); // TODO:需设为具体的分布
                Element argsTag = failureTag.addElement("Args");
                Double value = new Double(paramData.getTaskMtbcfRegulate());
                value = 1.0/value;
                argsTag.addAttribute("value", value.toString());
                if (1==paramData.getRepairable()) {
                    Element repairTag = element.addElement("Repair");
                    repairTag.addAttribute("Dist", "EXP"); // TODO:需设为具体的分布
                    argsTag = repairTag.addElement("Args");
                    value = new Double(paramData.getRepairMttcr());
                    value = 1.0/value;
                    argsTag.addAttribute("value", value.toString());
                    Element repairTimeLimitTag = element.addElement("RepairTimeLimit");
                    repairTimeLimitTag.setText(paramData.getRepairMttcr());
                }
            } else if ("10".equals(xhProductModel.getProductType())) {
                // 虚单位
                ModelRbd rbdXDY = modelRbdDao.getDiagramOfXDY(dataId);
                if (rbdXDY == null) return;
                List<Algorithm> algorithmListXDY = algorithmDao.getListByModelId(rbdXDY.getId());
                List<ModelNode> modelNodeAndVnodeListXDY =modelNodeAlgorithmDao.getListByModelId(rbdXDY.getId());
                Algorithm endAlgo = algorithmListXDY.stream().filter(item ->
                        "end".equals(item.getAlgorithmType())).collect(Collectors.toList()).get(0);
                ModelNode computerNode = modelNodeAndVnodeListXDY.stream().filter(item ->
                        endAlgo.getComputerList().equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2DOM(algorithmListXDY, modelNodeAndVnodeListXDY, computerNode, parent);
            }
    private void createAlgorithm(Long modelId,
                                 RbdTreeNode root,
                                 List<Algorithm> algorithmList,
                                 List<ModelNode> modelNodeAndVnodeList) {
        List<RbdTreeNode> children = root.getChildren();
        if (children.size() == 0) {
            ModelNode node = new ModelNode();
            node.setModelId(modelId);
            node.setId(root.getId());
            node.setPicId(root.getPicId());
            node.setDataId(root.getDataId());
            node.setNodeType(root.getNodeType());
            node.setName(root.getName());
            node.setVoteNum(root.getVoteNum());
            modelNodeAndVnodeList.add(node);
        } else {
            // vnode（运算节点）
            Algorithm algo = algorithmList.stream().filter(item ->
                    node.getId().equals(item.getId())).collect(Collectors.toList()).get(0);
            Element element = parent.addElement("Logic");
            element.addAttribute("Name", algo.getId().toString());
            if ("series".equals(algo.getAlgorithmType())) {
                element.addAttribute("Type", "SERIES");
            } else if ("parallel".equals(algo.getAlgorithmType())) {
                element.addAttribute("Type", "PARALLEL");
            } else if ("vote".equals(algo.getAlgorithmType())) {
                element.addAttribute("Type", "VOTE");
                element.addAttribute("VoteValue", algo.getVoteNum().toString());
            } else if ("switch".equals(algo.getAlgorithmType())) {
                element.addAttribute("Type", "STANDBY");
            } else if ("bridge".equals(algo.getAlgorithmType())) {
                element.addAttribute("Type", "BRIDGE");
            }
            String[] computerNodeListStr = algo.getComputerList().split(",");
            for (String nodeStr : computerNodeListStr) {
                ModelNode nd = modelNodeAndVnodeList.stream().filter(item ->
                        nodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0);
                node2DOM(algorithmList, modelNodeAndVnodeList, nd, element);
            Algorithm algo = new Algorithm();
            algo.setModelId(modelId);
            algo.setId(root.getId());
            algo.setComputerId(algo.getId());
            algo.setAlgorithmType(root.getAlgorithmType());
            algo.setModelType(algo.getAlgorithmType());
            algo.setStep(Integer.valueOf(root.getName().substring(1)));
            algo.setVoteNum(root.getVoteNum());
            algo.setObjectList(root.getChildren().stream().map(item ->
                    item.getName()).collect(Collectors.joining(",")));
            algo.setComputerList(root.getChildren().stream().map(item ->
                    item.getId().toString()).collect(Collectors.joining(",")));
            algorithmList.add(algo);
            ModelNode node = new ModelNode();
            node.setModelId(modelId);
            node.setId(root.getId());
            node.setPicId(root.getPicId());
            node.setDataId(root.getDataId());
            node.setNodeType(root.getNodeType());
            node.setName(root.getName());
            node.setVoteNum(root.getVoteNum());
            modelNodeAndVnodeList.add(node);
            for (RbdTreeNode treeNode : root.getChildren()) {
                createAlgorithm(modelId, treeNode, algorithmList, modelNodeAndVnodeList);
            }
        }
    }

    private boolean getAlgorithmFromRbd(ModelRbd modelRbd,
                                        List<ModelNode> modelNodeList,
                                        List<ModelLine> modelLineList,
                                        List<Algorithm> algorithmList,
                                        List<ModelNode> modelNodeAndVnodeList) {
        // 根据以下的构图规则来进行算法分解：
        // 1、节点的定义
        // 1-1) 运算节点：共2个：旁联、表决，且运算节点需放在被运算节点的右侧。
        // 1-2) 产品节点：产品模型中的节点
        // 1-3) 连接节点：共3个：start、end、connect
        // 1-4) 虚节点：代替基本模型，构图规则上等效于产品节点
        // 2、基本模型的定义
        // 2-1) 串联：没有专门的表示符号，由节点间的连接关系定义。2个及以上的节点（产品节点或虚节点）只构成1条路径，终端节点只有1个出口（入口个数无限制）。
        // 2-2) 并联：没有专门的表示符号，由节点间的连接关系定义。2个及以上的节点（产品节点或虚节点）都只有1个入口和出口，且这些节点拥有同一个入口节点和同一个出口节点。
        // 2-3) 旁联：由专门的旁联运算符表示，每条旁联支路只有1个节点（产品节点或虚节点），这些节点都以该旁联节点为出口节点，且这些节点拥有同一个入口节点。
        // 2-4) 表决：由专门的表决运算符表示，每条表决支路只有1个节点（产品节点或虚节点），这些节点都以该表决节点为出口节点，且这些节点拥有同一个入口节点。
        // 2-5) 桥联：没有专门的表示符号，由节点间的连接关系定义。
        // 3、根据以上基本模型的定义，不断将基本模型简化为虚节点，直至简化完毕，或者无法简化为止。
        boolean isEnd = false; // 图形简化完毕（全部简化没了）
        boolean hasSimplified = false; // 至少简化了一处图形
        do {
            hasSimplified = false;
            hasSimplified = simplifySeries(modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyParallel(modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyOperator("switch", modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyOperator("vote", modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            hasSimplified = simplifyBridge(modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList, hasSimplified);
            isEnd = simplifyEnd(modelRbd.getId(), modelNodeList, modelLineList, algorithmList, modelNodeAndVnodeList);
        } while (!isEnd && hasSimplified);

        return isEnd;
    /**
     * 对树形结构进行预处理，包括：
     * 1）将root的algorithmType替换为end，并去掉start和end节点
     * 2）start与end间只有1个逻辑运算块，则去掉最外层的series
     *
     * @param root
     */
    private void deleteStartEnd(RbdTreeNode root) {
        root.setAlgorithmType("end");
        List<RbdTreeNode> children = root.getChildren();
        children.remove(children.size() - 1);
        children.remove(0);
        if (children.size() > 1 ||
                !"vnode".equals(children.get(0).getNodeType())) {
            RbdTreeNode subNode = new RbdTreeNode();
            subNode.setAlgorithmType("series");
            subNode.setId(UUIDUtil.generateId());
            subNode.setName("v0");
            subNode.setNodeType("vnode");
            subNode.getChildren().addAll(children);
            List<RbdTreeNode> list = new ArrayList<>();
            list.add(subNode);
            root.setChildren(list);
        }
    }

    private boolean simplifyEnd(Long modelId,
                                List<ModelNode> modelNodeList,
                                List<ModelLine> modelLineList,
                                List<Algorithm> algorithmList,
                                List<ModelNode> modelNodeAndVnodeList) {
        ModelNode endNode = modelNodeList.stream().filter(item ->
                "end".equals(item.getNodeType())).collect(Collectors.toList()).get(0);
        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;

        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;

        // 删除节点及连线
        modelLineList.remove(lineToEnd);
        modelLineList.remove(lineToNode);
        modelNodeList.remove(endNode);
        modelNodeList.remove(node);
        modelNodeList.remove(startNode);

        // 生成结束的算法步骤
        // 新增algorithm
        Algorithm algorithm = new Algorithm();
        Long id = UUIDUtil.generateId();
        algorithm.setId(id);
        algorithm.setModelId(modelId);
        algorithm.setComputerId(id);
        algorithm.setModelType(endNode.getNodeType());
        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);
        algorithmList.add(algorithm);

        // 新增结束的虚节点
        ModelNode vnode = new ModelNode();
        vnode.setId(id);
        vnode.setPicId(id.toString());
        vnode.setModelId(modelId);
        vnode.setNodeType("vnode");
        vnode.setName("v"+algorithm.getStep());
        modelNodeAndVnodeList.add(vnode);

        return true;
    }

    private boolean simplifySeries(Long modelId,
                                   List<ModelNode> modelNodeList,
                                   List<ModelLine> modelLineList,
                                   List<Algorithm> algorithmList,
                                   List<ModelNode> modelNodeAndVnodeList,
                                   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;

        for (ModelNode startNode : startNodes) {
            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;

            ModelNode endNode = result.get(result.size()-1);
            if ("start,switch,vote".contains(endNode.getNodeType()) || endNode.getOutLineNum()!=1) {
                result.remove(endNode);
    /**
     * 对树形结构进行预处理：
     * 去掉逻辑运算块中用于排版的外层series
     *
     * @param root
     */
    private void deleteSeriesForAutoArrange(RbdTreeNode root) {
        List<RbdTreeNode> children = root.getChildren();
        for (int i = 0; i < children.size(); i++) {
            RbdTreeNode treeNode = children.get(i);
            if ("vnode".equals(treeNode.getNodeType()) &&
                    "series".equals(treeNode.getAlgorithmType()) &&
                    "connect".equals(treeNode.getChildren().get(0).getNodeType())) {
                children.set(i, treeNode.getChildren().get(1));
            }
            List<ModelNode> realSeriesNodes = result.stream().filter(item ->
                    !"connect".equals(item.getNodeType())).collect(Collectors.toList());
            if (realSeriesNodes.size()<1) {
                if (result.size() < 2) continue;
                // 替换成连线
                replaceToLineSeries(modelNodeList, modelLineList, result);
            } else if (realSeriesNodes.size()==1) {
                if (result.size() < 2) continue;   // path上只有该产品节点（node/vnode）自己，无需做什么
                // 将path替换成该节点
                replaceToTheNodeSeries(modelNodeList, modelLineList,
                        result, realSeriesNodes.get(0));
            } else {
                // 将path替换成虚节点
                replaceToVnodeSeries(modelId, modelNodeList, modelLineList,
                        algorithmList, modelNodeAndVnodeList, result, realSeriesNodes);
            }
            hasSimplified = true;
        }

        return hasSimplified;
    }

    private void replaceToLineSeries(List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList,
                                     List<ModelNode> path) {
        // 获取path的起点的出口线
        ModelNode finalNodeStart = path.get(0);
        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++) {
            ModelNode finalNode = path.get(i);
            if (i < path.size() - 1) {
                // 将入口线删除
                List<ModelLine> lines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(lines);
                // 删除节点
                modelNodeList.remove(finalNode);
                calcInOutLineNum(finalNode, modelLineList);
            }
        }

        // 将path的起点的出口线改为连接到path的结束点
        for (ModelLine line : outLines) {
            line.setBeginCell(finalNodeEnd.getPicId());
        }

        calcInOutLineNum(finalNodeStart, modelLineList);
        calcInOutLineNum(finalNodeEnd, modelLineList);
    }

    private void replaceToTheNodeSeries(List<ModelNode> modelNodeList,
                                      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);
        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++) {
            ModelNode finalNode = path.get(i);
            if (i < path.size() - 1) {
                // 将入口线删除
                List<ModelLine> lines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(lines);
            }
            if (!finalNode.getId().equals(theNode.getId())) {
                modelNodeList.remove(finalNode);
                calcInOutLineNum(finalNode, modelLineList);
            }
        }

        // 将path的起点的出口线改为连接到theNode
        for (ModelLine line : outLines) {
            line.setBeginCell(theNode.getPicId());
        }
        // 将path的结束点的入口线改为连接到theNode
        for (ModelLine line : inLines) {
            line.setEndCell(theNode.getPicId());
        }

        calcInOutLineNum(finalNodeStart, modelLineList);
        calcInOutLineNum(finalNodeEnd, modelLineList);
        calcInOutLineNum(theNode, modelLineList);
    }

    private void replaceToVnodeSeries(Long modelId,
                                      List<ModelNode> modelNodeList,
                                      List<ModelLine> modelLineList,
                                      List<Algorithm> algorithmList,
                                      List<ModelNode> modelNodeAndVnodeList,
                                      List<ModelNode> path,
                                      List<ModelNode> seriesNodes) {
        // 新增algorithm
        List<String> computerList = createVnodeComputerList("series", algorithmList, modelNodeAndVnodeList, seriesNodes);
        Algorithm algorithm = new Algorithm();
        Long id = UUIDUtil.generateId();
        algorithm.setId(id);
        algorithm.setModelId(modelId);
        algorithm.setComputerId(id);
        algorithm.setModelType("series");
        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);
        algorithmList.add(algorithm);

        // 新增虚节点
        ModelNode vnode = new ModelNode();
        vnode.setId(id);
        vnode.setPicId(id.toString());
        vnode.setModelId(modelId);
        vnode.setNodeType("vnode");
        vnode.setName("v"+algorithm.getStep());
        vnode.setPositionX(path.get(0).getPositionX());
        vnode.setPositionY(path.get(0).getPositionY());
        modelNodeList.add(vnode);
        modelNodeAndVnodeList.add(vnode);

        // 将path替换为该虚节点
        for (int i=0; i<path.size(); i++) {
            ModelNode finalNode = path.get(i);
            if (i==0) {
                // 将该节点的出口线改为连接到虚节点
                List<ModelLine> outLines = modelLineList.stream().filter(item ->
                        item.getBeginCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                for (ModelLine line : outLines) {
                    line.setBeginCell(vnode.getPicId());
                }
                // 将该节点的入口线删除
                List<ModelLine> inLines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(inLines);
            }
            if (i==path.size()-1) {
                // 将该节点的入口线改为连接到虚节点
                List<ModelLine> inLines = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                for (ModelLine line : inLines) {
                    line.setEndCell(vnode.getPicId());
                }
                // 将该节点的出口线删除
                List<ModelLine> outLines = modelLineList.stream().filter(item ->
                        item.getBeginCell().equals(finalNode.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(outLines);
            }
            // 删除该节点的出入口线
            List<ModelLine> inOutLines = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(finalNode.getPicId()) || item.getBeginCell().equals(finalNode.getPicId())
            ).collect(Collectors.toList());
            modelLineList.removeAll(inOutLines);
            // 删除该节点
            modelNodeList.remove(finalNode);
            calcInOutLineNum(finalNode, modelLineList);
        }

        calcInOutLineNum(vnode, modelLineList);
    }

    private List<String> createVnodeComputerList(String type,
                                                 List<Algorithm> algorithmList,
                                                 List<ModelNode> modelNodeAndVnodeList,
                                                 List<ModelNode> nodes) {
        // 调整节点顺序
        List<ModelNode> sortedNodes = null;
        if ("bridge".equals(type)) {
            if (nodes.get(1).getPositionY() < nodes.get(4).getPositionY()) {
                sortedNodes = nodes;
            } else {
                sortedNodes = new ArrayList<>();
                sortedNodes.add(nodes.get(3));
                sortedNodes.add(nodes.get(4));
                sortedNodes.add(nodes.get(2));
                sortedNodes.add(nodes.get(0));
                sortedNodes.add(nodes.get(1));
            }
        } else if ("parallel".equals(type)) {
            // 把虚节点内部的并联节点全部拿出来，进行大排序
            sortedNodes = new ArrayList<>();
            for (ModelNode node : nodes) {
                if ("node".equals(node.getNodeType())) {
                    sortedNodes.add(node);
                } else {
                    // vnode
                    Algorithm algorithm = algorithmList.stream().filter(item ->
                            item.getId().equals(node.getId())).collect(Collectors.toList()).get(0);
                    if (type.equals(algorithm.getAlgorithmType())) {
                        String[] pNodesStrArr = algorithm.getComputerList().split(",");
                        for (String pNodeStr : pNodesStrArr) {
                            sortedNodes.add(modelNodeAndVnodeList.stream().filter(item ->
                                    pNodeStr.equals(item.getId().toString())).collect(Collectors.toList()).get(0));
                        }
                        algorithmList.remove(algorithm);
                        modelNodeAndVnodeList.remove(node);
                    } else {
                        sortedNodes.add(node);
                    }
                }
            }
            sortedNodes.sort(Comparator.comparing(ModelNode::getPositionY));
        } else {
            sortedNodes = Arrays.asList(new ModelNode[nodes.size()]);
            Collections.copy(sortedNodes, nodes);
            if ("series".equals(type)) {
                Collections.reverse(sortedNodes);
            } else {
                sortedNodes.sort(Comparator.comparing(ModelNode::getPositionY));
            }
        }

        String computerIdList = "";
        String objectList = "";
        if ("parallel".equals(type)) {
            for (ModelNode node : sortedNodes) {
                objectList += "".equals(objectList) ? node.getName() : "," + node.getName();
                computerIdList += "".equals(computerIdList) ? node.getId().toString() : "," + node.getId().toString();
            }
        } else {
            for (ModelNode node : sortedNodes) {
                if ("node".equals(node.getNodeType())) {
                    objectList += "".equals(objectList) ? node.getName() : "," + node.getName();
                    computerIdList += "".equals(computerIdList) ? node.getId().toString() : "," + node.getId().toString();
                } else {
                    // vnode
                    Algorithm algorithm = algorithmList.stream().filter(item ->
                            item.getId().equals(node.getId())).collect(Collectors.toList()).get(0);
                    if ("series".equals(type) && type.equals(algorithm.getAlgorithmType())) {
                        objectList += "".equals(objectList) ? algorithm.getObjectList() : "," + algorithm.getObjectList();
                        computerIdList += "".equals(computerIdList) ? algorithm.getComputerList() : "," + algorithm.getComputerList();
                        algorithmList.remove(algorithm);
                        modelNodeAndVnodeList.remove(node);
                    } else {
                        objectList += "".equals(objectList) ? node.getName() : "," + node.getName();
                        computerIdList += "".equals(computerIdList) ? node.getId().toString() : "," + node.getId().toString();
                    }
                }
            }
        }

        List<String> result = new ArrayList<>();
        result.add(computerIdList);
        result.add(objectList);
        return result;
    }

    private void seekPathSeries(List<ModelNode> modelNodeList,
                                List<ModelLine> modelLineList,
                                ModelNode startNode,
                                List<ModelNode> result) {
        ModelLine inLine = modelLineList.stream().filter(item ->
                item.getEndCell().equals(startNode.getPicId())).collect(Collectors.toList()).get(0);
        ModelNode pathNode = modelNodeList.stream().filter(item ->
                inLine.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        result.add(pathNode);
        if (pathNode.getOutLineNum()!=1 || pathNode.getInLineNum()!=1) return;
        if ("switch,vote".contains(pathNode.getNodeType())) return;
        seekPathSeries(modelNodeList, modelLineList, pathNode, result);
    }

    private boolean simplifyParallel(Long modelId,
                                     List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList,
                                     List<Algorithm> algorithmList,
                                     List<ModelNode> modelNodeAndVnodeList,
                                     boolean hasSimplified) {
        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;

        for (ModelNode startNode : startNodes) {
            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,
                    algorithmList, modelNodeAndVnodeList, startNode, inLines);
            if (hasSimplifiedMe) {
                hasSimplified = true;
            }
        }

        return hasSimplified;
    }

    private boolean simplifyParallelGroup(Long modelId,
                                        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) {
            List<ModelNode> path = getOneBranchParallel(modelNodeList, modelLineList, line);
            if (path.size() > 0) pathList.add(path);
        }
        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) {
                List<ModelNode> branchNodeList = new ArrayList<>();
                ModelNode endNode = getBranchNodesOneParallel(pathOneGroup, branchNodeList);
                if ("connect".equals(startNode.getNodeType()) && pathOneGroup.size()==lines.size()) {
                    // 替换成虚节点
                    modelNodeAndVnodeList.add(startNode);
                    replaceToVnode("parallel", modelId, modelNodeList, modelLineList,
                            algorithmList, modelNodeAndVnodeList, startNode, endNode, branchNodeList);
                } else {
                    // 新增虚节点
                    ModelNode vnode = new ModelNode();
                    Long id = UUIDUtil.generateId();
                    vnode.setId(id);
                    vnode.setPicId(id.toString());
                    vnode.setModelId(modelId);
                    vnode.setNodeType("vnode");
                    // 位置设置为并联中第一个节点的位置
                    vnode.setPositionX(branchNodeList.get(0).getPositionX());
                    vnode.setPositionY(branchNodeList.get(0).getPositionY());
//                    vnode.setPositionX(startNode.getPositionX());
//                    vnode.setPositionY(startNode.getPositionY());
                    modelNodeList.add(vnode);
                    modelNodeAndVnodeList.add(vnode);
                    ModelLine modelLineNew = new ModelLine();
                    Long picId2 = UUIDUtil.generateId();
                    modelLineNew.setId(picId2);
                    modelLineNew.setPicId(picId2.toString());
                    modelLineNew.setModelId(modelId);
                    modelLineNew.setBeginCell(vnode.getPicId());
                    modelLineNew.setEndCell(startNode.getPicId());
                    modelLineList.add(modelLineNew);
                    replaceToVnode("parallel", modelId, modelNodeList, modelLineList,
                            algorithmList, modelNodeAndVnodeList, vnode, endNode, branchNodeList);
                    calcInOutLineNum(startNode, modelLineList);
                }
                hasSimplified = true;
            }
        }

        return hasSimplified;
    }

    private List<ModelNode> getOneBranchParallel(List<ModelNode> modelNodeList,
                                                 List<ModelLine> modelLineList,
                                                 ModelLine line) {
        List<ModelNode> path = new ArrayList<>();
        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 path;
        ModelLine lineToBranchNode = inLines.get(0);
        ModelNode endNode = modelNodeList.stream().filter(item ->
                lineToBranchNode.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        path.add(branchNode);
        path.add(endNode);

        return path;
    }

    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);
            if (endNodePathsMap.containsKey(endNode)) {
                endNodePathsMap.get(endNode).add(path);
            } else {
                List<List<ModelNode>> paths = new ArrayList<>();
                paths.add(path);
                endNodePathsMap.put(endNode, paths);
            }
        }
        return endNodePathsMap;
    }

    private ModelNode getBranchNodesOneParallel(List<List<ModelNode>> paths,
                                           List<ModelNode> branchNodeList) {
        ModelNode endNode = null;
        for (List<ModelNode> path : paths) {
            branchNodeList.add(path.get(0));
            endNode = path.get(path.size()-1);
        }
        return endNode;
    }

    private boolean simplifyBridge(Long modelId,
                                   List<ModelNode> modelNodeList,
                                   List<ModelLine> modelLineList,
                                   List<Algorithm> algorithmList,
                                   List<ModelNode> modelNodeAndVnodeList,
                                   boolean hasSimplified) {
        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;

        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) {
                hasSimplifiedMe = simplifyBridgeOneLinePair(modelId, modelNodeList, modelLineList,
                        algorithmList, modelNodeAndVnodeList, startNode, linePair);
                if (hasSimplifiedMe) {
                    hasSimplified = true;
                    break;
                }
            }
        }

        return hasSimplified;
    }

    private boolean simplifyBridgeOneLinePair(Long modelId,
                                              List<ModelNode> modelNodeList,
                                              List<ModelLine> modelLineList,
                                              List<Algorithm> algorithmList,
                                              List<ModelNode> modelNodeAndVnodeList,
                                              ModelNode startNode,
                                              ModelLinePair linePair) {
        ModelNode node1 = null;
        ModelNode node2 = null;
        ModelNode node3 = null;
        ModelNode node4 = null;
        ModelNode node5 = null;
        ModelNode nodeTmp1 = modelNodeList.stream().filter(item ->
                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);
        calcInOutLineNum(nodeTmp1, modelLineList);
        calcInOutLineNum(nodeTmp2, modelLineList);
        if (nodeTmp1.getOutLineNum()!=1 || nodeTmp2.getOutLineNum()!=1) return false;
        if (nodeTmp1.getInLineNum()<1 || nodeTmp1.getInLineNum()>2) return false;
        if (nodeTmp2.getInLineNum()<1 || nodeTmp2.getInLineNum()>2) return false;
        if ((nodeTmp1.getInLineNum() + nodeTmp2.getInLineNum())!=3) return false;
        if (nodeTmp1.getInLineNum()==1) {
            node2 = nodeTmp1;
            node5 = nodeTmp2;
        } else {
            node2 = nodeTmp2;
            node5 = nodeTmp1;
        }
        ModelNode finalNode = node2;
        ModelLine line1To2 = modelLineList.stream().filter(item ->
                item.getEndCell().equals(finalNode.getPicId())).collect(Collectors.toList()).get(0);
        node1 = modelNodeList.stream().filter(item ->
                line1To2.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        if (node1.getInLineNum()!=1 || node1.getOutLineNum()!=2) return false;
        ModelNode finalNode1 = node1;
        List<ModelLine> outLinesFrom1 = modelLineList.stream().filter(item ->
                item.getBeginCell().equals(finalNode1.getPicId())).collect(Collectors.toList());
        if (outLinesFrom1.get(0).getEndCell().equals(node2.getPicId())) {
            node3 = modelNodeList.stream().filter(item ->
                    outLinesFrom1.get(1).getEndCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        } else {
            node3 = modelNodeList.stream().filter(item ->
                    outLinesFrom1.get(0).getEndCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        }
        if (node3.getId().equals(node5.getId())) return false;
        if (node3.getInLineNum()!=1 || node3.getOutLineNum()!=1) return false;
        ModelNode finalNode2 = node3;
        ModelLine outLineFrom3 = modelLineList.stream().filter(item ->
                item.getBeginCell().equals(finalNode2.getPicId())).collect(Collectors.toList()).get(0);
        if (!outLineFrom3.getEndCell().equals(node5.getPicId())) return false;
        ModelNode finalNode3 = node5;
        List<ModelLine> inLinesTo5 = modelLineList.stream().filter(item ->
                item.getEndCell().equals(finalNode3.getPicId())).collect(Collectors.toList());
        if (inLinesTo5.get(0).getBeginCell().equals(node3.getPicId())) {
            node4 = modelNodeList.stream().filter(item ->
                    inLinesTo5.get(1).getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        } else {
            node4 = modelNodeList.stream().filter(item ->
                    inLinesTo5.get(0).getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        }
        if (node4.getId().equals(node1.getId())) return false;
        if (node4.getId().equals(node2.getId())) return false;
        if (node4.getInLineNum()!=1 || node4.getOutLineNum()!=1) return false;
        ModelNode finalNode4 = node1;
        ModelLine lineTo1 = modelLineList.stream().filter(item ->
                item.getEndCell().equals(finalNode4.getPicId())).collect(Collectors.toList()).get(0);
        ModelNode finalNode5 = node4;
        ModelLine lineTo4 = modelLineList.stream().filter(item ->
                item.getEndCell().equals(finalNode5.getPicId())).collect(Collectors.toList()).get(0);
        nodeTmp1 = modelNodeList.stream().filter(item ->
                lineTo1.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        nodeTmp2 = modelNodeList.stream().filter(item ->
                lineTo4.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
        if (!nodeTmp1.getId().equals(nodeTmp2.getId())) return false;
        ModelNode endNode = nodeTmp1;
        List<ModelNode> branchNodeList = new ArrayList<>();
        branchNodeList.add(node1);
        branchNodeList.add(node2);
        branchNodeList.add(node3);
        branchNodeList.add(node4);
        branchNodeList.add(node5);

        if ("connect".equals(startNode.getNodeType()) && startNode.getInLineNum()==2) {
            // 替换成虚节点
            modelNodeAndVnodeList.add(startNode);
            replaceToVnode("bridge", modelId, modelNodeList, modelLineList,
                    algorithmList, modelNodeAndVnodeList, startNode, endNode, branchNodeList);
        } else {
            // 新增虚节点
            ModelNode vnode = new ModelNode();
            Long id = UUIDUtil.generateId();
            vnode.setId(id);
            vnode.setPicId(id.toString());
            vnode.setModelId(modelId);
            vnode.setNodeType("vnode");
            // 将位置设置为第一个分支的
            vnode.setPositionX(node2.getPositionX());
            vnode.setPositionY(node2.getPositionY());
//            vnode.setPositionX(startNode.getPositionX());
//            vnode.setPositionY(startNode.getPositionY());
            modelNodeList.add(vnode);
            modelNodeAndVnodeList.add(vnode);
            ModelLine modelLineNew = new ModelLine();
            Long picId2 = UUIDUtil.generateId();
            modelLineNew.setId(picId2);
            modelLineNew.setPicId(picId2.toString());
            modelLineNew.setModelId(modelId);
            modelLineNew.setBeginCell(vnode.getPicId());
            modelLineNew.setEndCell(startNode.getPicId());
            modelLineList.add(modelLineNew);
            replaceToVnode("bridge", modelId, modelNodeList, modelLineList,
                    algorithmList, modelNodeAndVnodeList, vnode, endNode, branchNodeList);
            calcInOutLineNum(startNode, modelLineList);
        }

        return true;
    }

    private void calcInOutLineNumAllNode(List<ModelNode> modelNodeList, List<ModelLine> modelLineList) {
        for (ModelNode node : modelNodeList) {
            calcInOutLineNum(node, modelLineList);
            deleteSeriesForAutoArrange(children.get(i));
        }
    }

    private void calcInOutLineNum(ModelNode node, List<ModelLine> modelLineList) {
        List<ModelLine> inLines = modelLineList.stream().filter(item ->
                item.getEndCell().equals(node.getPicId())).collect(Collectors.toList());
        List<ModelLine> outLines = modelLineList.stream().filter(item ->
                item.getBeginCell().equals(node.getPicId())).collect(Collectors.toList());
        node.setInLineNum(inLines.size());
        node.setOutLineNum(outLines.size());
    }

    // 找出所有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();
                linePair.setLine1(lines.get(i));
                linePair.setLine2(lines.get(j));
                linePairs.add(linePair);
    /**
     * 用于自动排版：将桥联转换为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);
        }
        return linePairs;
    }

    private boolean simplifyOperator(String operator,
                                     Long modelId,
                                     List<ModelNode> modelNodeList,
                                     List<ModelLine> modelLineList,
                                     List<Algorithm> algorithmList,
                                     List<ModelNode> modelNodeAndVnodeList,
                                     boolean hasSimplified) {
        List<ModelNode> opNodes = modelNodeList.stream().filter(item ->
                operator.equals(item.getNodeType())).collect(Collectors.toList());
        if (opNodes.size()==0) return hasSimplified;

        for (ModelNode opNode : opNodes) {
            List<ModelLine> lines = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(opNode.getPicId())).collect(Collectors.toList());
            boolean thisNodeSuccess = true;
            ModelNode endNode = null;
            List<ModelNode> branchNodeList = new ArrayList<>();
            for (ModelLine line : lines) {
                ModelNode curEndNode = handleOneBranch(modelNodeList, modelLineList, line, branchNodeList);
                if (curEndNode == null) {
                    thisNodeSuccess = false;
                    break;
                }
                if (endNode == null) {
                    endNode = curEndNode;
                } else {
                    if (!endNode.getId().equals(curEndNode.getId())) {
                        thisNodeSuccess = false;
                        break;
                    }
                }
            }
            if (thisNodeSuccess) {
                modelNodeAndVnodeList.add(opNode);
                replaceToVnode(opNode.getNodeType(), modelId, modelNodeList, modelLineList,
                        algorithmList, modelNodeAndVnodeList, opNode, endNode, branchNodeList);
                hasSimplified = true;
            }
        }

        return hasSimplified;
    }

    private void replaceToVnode(String type,
                                Long modelId,
                                List<ModelNode> modelNodeList,
                                List<ModelLine> modelLineList,
                                List<Algorithm> algorithmList,
                                List<ModelNode> modelNodeAndVnodeList,
                                ModelNode startNode,
                                ModelNode endNode,
                                List<ModelNode> branchNodeList) {
        // 新增algorithm
        List<String> computerList = createVnodeComputerList(type, algorithmList, modelNodeAndVnodeList, branchNodeList);
        Algorithm algorithm = new Algorithm();
        Long id = UUIDUtil.generateId();
        algorithm.setId(id);
        algorithm.setModelId(modelId);
        algorithm.setComputerId(id);
        algorithm.setModelType(type);
        algorithm.setAlgorithmType(type);
        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);
        algorithmList.add(algorithm);

        // 替换为虚节点
        for (ModelNode node : branchNodeList) {
            List<ModelLine> branchNodeLineList = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node.getPicId()) || item.getBeginCell().equals(node.getPicId())
            ).collect(Collectors.toList());
            modelLineList.removeAll(branchNodeLineList);
            modelNodeList.remove(node);
            calcInOutLineNum(node, modelLineList);
        }
        startNode.setId(id);
        startNode.setNodeType("vnode");
        startNode.setName("v"+algorithm.getStep());

        ModelLine modelLineNew = new ModelLine();
        Long picId2 = UUIDUtil.generateId();
        modelLineNew.setId(picId2);
        modelLineNew.setPicId(picId2.toString());
        modelLineNew.setModelId(modelId);
        modelLineNew.setBeginCell(endNode.getPicId());
        modelLineNew.setEndCell(startNode.getPicId());
        modelLineList.add(modelLineNew);

        calcInOutLineNum(startNode, modelLineList);
        calcInOutLineNum(endNode, modelLineList);
    }

    private ModelNode handleOneBranch(List<ModelNode> modelNodeList,
                                      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;
        ModelLine lineToBranchNode = inLines.get(0);
        ModelNode endNode = modelNodeList.stream().filter(item ->
                lineToBranchNode.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);

        branchNodeList.add(branchNode);
        return endNode;
    }

    private void getNodeAndLineFromRbd(Long modelId,
                                       JSONArray rbdJsonArray,
                                       List<ModelNode> modelNodeList,
                                       List<ModelLine> modelLineList,
                                       List<ProductImg> productImgList) {
        for (int i = 0; i < rbdJsonArray.size(); i++) {
            JSONObject jsonObject = rbdJsonArray.getJSONObject(i);
            String shape = jsonObject.get("shape").toString();
            if ("edge".equals(shape)) {
                ModelLine modelLine = new ModelLine();
                modelLine.setId(UUIDUtil.generateId());
                modelLine.setModelId(modelId);
                modelLine.setPicId(jsonObject.get("id").toString());
                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)){
                ModelNode modelNode = new ModelNode();
                modelNode.setId(UUIDUtil.generateId());
                modelNode.setModelId(modelId);
                modelNode.setPicId(jsonObject.get("id").toString());
                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()));
                Object voteNum = JsonUtils2.getJsonValueByPath(jsonObject, "data/voteNum".split("/"));
                if (voteNum!=null && StringUtils.isNotBlank(voteNum.toString())) {
                    modelNode.setVoteNum(Integer.valueOf(voteNum.toString()));
                }
                if ("node".equals(modelNode.getNodeType())) {
                    ProductImg productImg = new ProductImg();
                    String dataId = JsonUtils2.getJsonValueByPath(jsonObject, "data/dataId".split("/")).toString();
                    modelNode.setDataId(Long.valueOf(dataId));
                    modelNode.setNodeTypeExt(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeTypeExt".split("/")).toString());
                    Object name = JsonUtils2.getJsonValueByPath(jsonObject, "attrs/text/text".split("/"));
                    modelNode.setName(name==null ? "" : name.toString());

                    productImg.setDataId(dataId);
                    String productType = JsonUtils2.getJsonValueByPath(jsonObject, "data/productType".split("/")).toString();
                    productImg.setProductType(productType);
                    if ("product_sb".equals(productType)) {
                        Object obj = JsonUtils2.getJsonValueByPath(jsonObject, "data/reliabDistribType".split("/"));
                        if (obj != null && StringUtils.isNotBlank(obj.toString())) {
                            productImg.setReliabDistribType(Integer.valueOf(obj.toString()));
                        }
                        productImg.setTaskMtbcf(JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcf".split("/")).toString());
                        productImg.setTaskMtbcfOther(JsonUtils2.getJsonValueByPath(jsonObject, "data/taskMtbcfOther".split("/")).toString());
                        obj = JsonUtils2.getJsonValueByPath(jsonObject, "data/isRepair".split("/"));
                        if (obj != null && StringUtils.isNotBlank(obj.toString())) {
                            productImg.setIsRepair(Integer.valueOf(obj.toString()));
                        }
                        if (1 == productImg.getIsRepair()) {
                            obj = JsonUtils2.getJsonValueByPath(jsonObject, "data/repairDistribType".split("/"));
                            if (obj != null && StringUtils.isNotBlank(obj.toString())) {
                                productImg.setRepairDistribType(Integer.valueOf(obj.toString()));
                            }
                            productImg.setRepairMttcr(JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcr".split("/")).toString());
                            productImg.setRepairMttcrOther(JsonUtils2.getJsonValueByPath(jsonObject, "data/repairMttcrOther".split("/")).toString());
                        }
                    }
                    productImgList.add(productImg);
                }
                modelNodeList.add(modelNode);
            }
        }
//        calcLineSortAll(modelNodeList, modelLineList);
    }

/*
    private void calcLineSortAll(List<ModelNode> modelNodeList,
                                 List<ModelLine> modelLineList) {
        for (ModelNode node : modelNodeList) {
            List<ModelLine> inLines = modelLineList.stream().filter(item ->
                    item.getEndCell().equals(node.getPicId())).collect(Collectors.toList());
            if (inLines.size() < 1) continue;
            for (ModelLine line : inLines) {
                ModelNode beginNode = modelNodeList.stream().filter(item ->
                        line.getBeginCell().equals(item.getPicId())).collect(Collectors.toList()).get(0);
                line.setLineSort(beginNode.getPositionY());
    private void calcPosition(JSONArray rbdJsonArray, RbdTreeNode block, Map<String, RbdTreeNode> nodeMap) {
        if (block.getNodeType().equals("node")) {
            setNodePositionXY(rbdJsonArray, block,nodeMap);
        } 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, nodeMap);
                    subBlockX = subBlockX + selfWidth;

                }
            } else {

                Double subBlockY = block.getBlockY() + (descentHeight - blockHeight) / 2;
                Double firstSubBlockY = subBlockY;

                // 设置connect的位置
                RbdTreeNode connectBlock = new RbdTreeNode();
                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());
                connectBlock.setBlockY(firstSubBlockY);
                connectBlock.setBlockWidth(LAYOUT_CELL_SIZE_X);
                connectBlock.setBlockHeight(blockHeight);
                setNodePositionXY(rbdJsonArray, connectBlock, nodeMap);

                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, nodeMap);
                }

                // 设置运算符的位置
                RbdTreeNode opeBlock = new RbdTreeNode();

                opeBlock.setPicId(block.getPicId());
                opeBlock.setNodeType("parallel");
                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);
                opeBlock.setBlockHeight(blockHeight);
                setNodePositionXY(rbdJsonArray, opeBlock, nodeMap);
            }
        }

    }
*/

    private void saveModel(ModelRbd modelRbd,
                           List<ModelNode> modelNodeList,
                           List<ModelLine> modelLineList,
                           List<Algorithm> algoList,
                           List<ModelNode> modelNodeAndVnodeList) {
        // 删除既有数据
        modelNodeDao.deleteByModelId(modelRbd.getId());
        modelLineDao.deleteByModelId(modelRbd.getId());
        algorithmDao.deleteByModelId(modelRbd.getId());
        modelNodeAlgorithmDao.deleteByModelId(modelRbd.getId());

        // 插入数据
        for (ModelNode modelNode : modelNodeList) {
            modelNodeDao.insert(modelNode);
        }
        for (ModelLine modelLine : modelLineList) {
            modelLineDao.insert(modelLine);
        }
        for (Algorithm algorithm : algoList) {
            algorithmDao.insert(algorithm);
        }
        for (ModelNode modelNode : modelNodeAndVnodeList) {
            modelNodeAlgorithmDao.insert(ModelNodeAlgorithm.from(modelNode));
        }

        // 更新RBD数据
        modelRbd.setPublishedContent(modelRbd.getContent());
        modelRbdDao.updateById(modelRbd);
    }

/*  ============解析模型的第1版，已不使用============
    private void analyzeRbdAndSave(Long modelId, String content, boolean saveFlag) {
        String diagramJsonStr = content;
//        String diagramJsonStr = "{\"cells\":[{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"26d1a5a6-0be8-4890-86a0-a33d429e6673\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"f91765b1-af48-4396-84ba-eb16e3476aa5\",\"port\":\"839cb2d9-59ca-4a39-a63c-26bf60cc6989\"},\"target\":{\"cell\":\"31585e99-58c7-4a98-8824-8000743b364d\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"f2286e46-84c7-4702-8670-d7cda22c34e5\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"f91765b1-af48-4396-84ba-eb16e3476aa5\",\"port\":\"839cb2d9-59ca-4a39-a63c-26bf60cc6989\"},\"target\":{\"cell\":\"5123ad82-18bb-46fe-9d93-138b24b54a15\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"2ab8b7f8-7fe2-490f-89c5-4250d4a62a78\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"31585e99-58c7-4a98-8824-8000743b364d\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"6df9adc8-cb83-405c-8482-633db0f3644f\",\"port\":\"f93ccd2f-dedd-47b1-9ad0-9be20c5db8a4\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"700c05a5-f151-4b28-8135-705ccf013522\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"5123ad82-18bb-46fe-9d93-138b24b54a15\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"6df9adc8-cb83-405c-8482-633db0f3644f\",\"port\":\"f93ccd2f-dedd-47b1-9ad0-9be20c5db8a4\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"feef2a57-3c72-4d69-92a6-c828c736b61a\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"6df9adc8-cb83-405c-8482-633db0f3644f\",\"port\":\"80d3bd61-1ed3-493a-b4e8-d4576e6fbfda\"},\"target\":{\"cell\":\"da634b2e-5ffc-4e1b-a636-f86ace9eb082\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"49e36d6f-6a94-4edc-9894-6dd825091706\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"f91765b1-af48-4396-84ba-eb16e3476aa5\",\"port\":\"839cb2d9-59ca-4a39-a63c-26bf60cc6989\"},\"target\":{\"cell\":\"2b6df966-4e19-4055-bb13-c4c083b18e58\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"ed8c1bfa-c0a6-4e9b-8697-862aef109bcf\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"f91765b1-af48-4396-84ba-eb16e3476aa5\",\"port\":\"839cb2d9-59ca-4a39-a63c-26bf60cc6989\"},\"target\":{\"cell\":\"323f5abe-05ed-419d-9d81-d25c7d3b19f3\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"70c6b5fb-1b48-4a2f-bacd-be0284134818\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"2b6df966-4e19-4055-bb13-c4c083b18e58\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"1f378f5e-066d-49bb-a6cc-de24a8882d65\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"6a134969-623b-428e-9b0c-436bae2d6608\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"323f5abe-05ed-419d-9d81-d25c7d3b19f3\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"1f378f5e-066d-49bb-a6cc-de24a8882d65\",\"port\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#5F95FF\"}},\"id\":\"51de5faf-1766-4dd1-abd0-eec2e867a322\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"1f378f5e-066d-49bb-a6cc-de24a8882d65\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"0bb2ba89-a92d-4b32-b3cd-45df2300fa34\",\"port\":\"61eaafd2-095b-41d6-8e34-862fb470b7a6\"}},{\"shape\":\"edge\",\"attrs\":{\"line\":{\"stroke\":\"#A2B1C3\"}},\"id\":\"161f78dc-1f44-4e43-9ced-e39d345aac78\",\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"#5F95FF\"},\"text\":{\"text\":\"\"}},\"position\":{\"distance\":0.5,\"angle\":180,\"options\":{\"keepGradient\":true,\"ensureLegibility\":true}}}],\"zIndex\":0,\"source\":{\"cell\":\"da634b2e-5ffc-4e1b-a636-f86ace9eb082\",\"port\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},\"target\":{\"cell\":\"0bb2ba89-a92d-4b32-b3cd-45df2300fa34\",\"port\":\"61eaafd2-095b-41d6-8e34-862fb470b7a6\"}},{\"position\":{\"x\":-350,\"y\":-280},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"},\"line\":{\"stroke\":\"orange\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"31585e99-58c7-4a98-8824-8000743b364d\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":1,\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"orange\"}}}]},{\"position\":{\"x\":-350,\"y\":-180},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"},\"line\":{\"stroke\":\"orange\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"5123ad82-18bb-46fe-9d93-138b24b54a15\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":2,\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"orange\"}}}]},{\"position\":{\"x\":-620,\"y\":-200},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"start\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/start.88f586e1.png\"},\"body\":{\"stroke\":\"#5F95FF\"},\"line\":{\"stroke\":\"orange\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"f91765b1-af48-4396-84ba-eb16e3476aa5\",\"data\":{\"dataId\":\"\",\"nodeType\":\"start\",\"nodeTypeExt\":\"\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"2ad6a8d5-d86d-49e6-908a-d317b61997c1\"},{\"group\":\"right\",\"id\":\"839cb2d9-59ca-4a39-a63c-26bf60cc6989\"},{\"group\":\"bottom\",\"id\":\"7048578f-94d9-4f75-b653-eb5f43ff55db\"},{\"group\":\"left\",\"id\":\"e7bb1134-4b4c-401d-89ea-e77ae24cbd03\"}]},\"zIndex\":3,\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"orange\"}}}]},{\"position\":{\"x\":-153,\"y\":-240},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"switchRight\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/switchRight.74768797.png\"},\"body\":{\"stroke\":\"#5F95FF\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"6df9adc8-cb83-405c-8482-633db0f3644f\",\"data\":{\"dataId\":\"\",\"nodeType\":\"switchRight\",\"nodeTypeExt\":\"\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"adceedb7-f842-4d1e-be3a-8b3cb0a7e3ce\"},{\"group\":\"right\",\"id\":\"80d3bd61-1ed3-493a-b4e8-d4576e6fbfda\"},{\"group\":\"bottom\",\"id\":\"8fa84779-80b2-4c91-8366-7dd4fa0d93ff\"},{\"group\":\"left\",\"id\":\"f93ccd2f-dedd-47b1-9ad0-9be20c5db8a4\"}]},\"zIndex\":4},{\"position\":{\"x\":-21,\"y\":-240},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"},\"line\":{\"stroke\":\"orange\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"da634b2e-5ffc-4e1b-a636-f86ace9eb082\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":5,\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"orange\"}}}]},{\"position\":{\"x\":170,\"y\":-100},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"end\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/end.814a7041.png\"},\"body\":{\"stroke\":\"#5F95FF\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"0bb2ba89-a92d-4b32-b3cd-45df2300fa34\",\"data\":{\"dataId\":\"\",\"nodeType\":\"end\",\"nodeTypeExt\":\"\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"223c9b3a-6baa-4bb8-99ba-c3300db9a942\"},{\"group\":\"right\",\"id\":\"2806bc8a-4e11-4657-9af9-089907985671\"},{\"group\":\"bottom\",\"id\":\"c56eed35-95fa-4e3c-adba-9847ef705e1c\"},{\"group\":\"left\",\"id\":\"61eaafd2-095b-41d6-8e34-862fb470b7a6\"}]},\"zIndex\":6},{\"position\":{\"x\":-350,\"y\":-54},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"2b6df966-4e19-4055-bb13-c4c083b18e58\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":7},{\"position\":{\"x\":-330,\"y\":40},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"323f5abe-05ed-419d-9d81-d25c7d3b19f3\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":8},{\"position\":{\"x\":-153,\"y\":-20},\"size\":{\"width\":60,\"height\":60},\"attrs\":{\"text\":{\"refY\":\"100%\",\"textVerticalAnchor\":\"top\",\"text\":\"logo\",\"style\":{\"color\":\"#080808\"},\"refY2\":4},\"image\":{\"xlink:href\":\"dist/img/logo.36cbc06d.png\"},\"body\":{\"stroke\":\"#5F95FF\"},\"line\":{\"stroke\":\"orange\"}},\"visible\":true,\"shape\":\"image\",\"id\":\"1f378f5e-066d-49bb-a6cc-de24a8882d65\",\"data\":{\"dataId\":\"123456\",\"nodeType\":\"node\",\"nodeTypeExt\":\"aaa\"},\"ports\":{\"groups\":{\"top\":{\"position\":\"top\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"right\":{\"position\":\"right\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"bottom\":{\"position\":\"bottom\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}},\"left\":{\"position\":\"left\",\"attrs\":{\"circle\":{\"r\":4,\"magnet\":true,\"stroke\":\"#5F95FF\",\"strokeWidth\":1,\"fill\":\"#fff\",\"style\":{\"visibility\":\"hidden\"}}}}},\"items\":[{\"group\":\"top\",\"id\":\"bc0336ec-7912-4720-aea7-e5869de77692\"},{\"group\":\"right\",\"id\":\"a977d555-b8c8-4578-9a8b-3097c405c1a8\"},{\"group\":\"bottom\",\"id\":\"fef0f533-9581-4831-ba65-427f097a3d17\"},{\"group\":\"left\",\"id\":\"01eb49d9-4b1c-466f-8263-935542436c7e\"}]},\"zIndex\":9,\"labels\":[{\"attrs\":{\"body\":{\"stroke\":\"orange\"}}}]}]}";

        JSONObject diagramJson = new JSONObject(diagramJsonStr);
        JSONArray diagramJsonArray = diagramJson.getJSONArray("cells");
        if (diagramJsonArray == null) return;

        List<ModelLine> modelLineList = new ArrayList<>();
        List<ModelNode> modelNodeList = new ArrayList<>();
        // 1. 解析出节点与边
        for (int i = 0; i < diagramJsonArray.size(); i++) {
            JSONObject jsonObject = diagramJsonArray.getJSONObject(i);
            String shape = jsonObject.get("shape").toString();
            if (shape.equals("edge")) {
                ModelLine modelLine = new ModelLine();
                modelLine.setId(UUIDUtil.generateId());
                modelLine.setPicId(jsonObject.get("id").toString());
                modelLine.setModelId(modelId);
                modelLine.setBeginCell(JsonUtils2.getJsonValueByPath(jsonObject, "source/cell".split("/")).toString());
                modelLine.setEndCell(JsonUtils2.getJsonValueByPath(jsonObject, "target/cell".split("/")).toString());
                modelLineList.add(modelLine);
            } else if (shape.equals("image")){
                ModelNode modelNode = new ModelNode();
                modelNode.setId(UUIDUtil.generateId());
                modelNode.setPicId(jsonObject.get("id").toString());
                modelNode.setModelId(modelId);
                modelNode.setNodeType(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeType".split("/")).toString());
                if ("node".equals(modelNode.getNodeType())) {
                    modelNode.setDataId(Long.valueOf(JsonUtils2.getJsonValueByPath(jsonObject, "data/dataId".split("/")).toString()));
                    modelNode.setNodeTypeExt(JsonUtils2.getJsonValueByPath(jsonObject, "data/nodeTypeExt".split("/")).toString());
                    modelNode.setName(JsonUtils2.getJsonValueByPath(jsonObject, "attrs/label/textWrap/text".split("/")).toString());
                }
                modelNodeList.add(modelNode);
            }
        }

        // 2. 对于有多根入口线的产品节点，将其上的表决、旁联、并联关系剥离成运算符节点，添加到该产品节点的前面，并添加相应的边
        List<ModelNode> nodesToAdd = new ArrayList<>();
        List<ModelLine> linesToAdd = new ArrayList<>();
        for (ModelNode modelNode: modelNodeList) {
            String picId = modelNode.getPicId();
            List<ModelLine> lineList = modelLineList.stream().filter(item->item.getEndCell().equals(picId)).collect(Collectors.toList());
            if (lineList.size()>1){
                if ("node,end".contains(modelNode.getNodeType())){
                    String nodeTypeExt = "";
                    if ("node".equals(modelNode.getNodeType())) {
                        nodeTypeExt = modelNode.getNodeTypeExt();
                    } else if ("end".equals(modelNode.getNodeType())) {
                        nodeTypeExt = "parallel";
                    }
                    if (StringUtils.isNotBlank(nodeTypeExt)){
                        ModelNode modelNodeNew =  new ModelNode();
                        Long nodeNewId = UUIDUtil.generateId();
                        modelNodeNew.setId(nodeNewId);
                        modelNodeNew.setPicId(nodeNewId.toString());
                        modelNodeNew.setModelId(modelId);
                        modelNodeNew.setNodeType(nodeTypeExt);
                        nodesToAdd.add(modelNodeNew);

                        ModelLine modelLineNew = new ModelLine();
                        Long lineNewId = UUIDUtil.generateId();
                        modelLineNew.setId(lineNewId);
                        modelLineNew.setPicId(lineNewId.toString());
                        modelLineNew.setModelId(modelId);
                        modelLineNew.setBeginCell(nodeNewId.toString());
                        modelLineNew.setEndCell(modelNode.getPicId());
                        linesToAdd.add(modelLineNew);

                        for(ModelLine nodelLine: lineList){
                            nodelLine.setEndCell(nodeNewId.toString());
                        }
                    }
                }
            }
        }
        modelNodeList.addAll(nodesToAdd);
        modelLineList.addAll(linesToAdd);

        // 3. 将最基本的串、并、旁联、表决替换为虚节点，不断简化图形，直至无法简化为止
        List<Algorithm> algoList = new ArrayList<>();
        boolean hasLeastOne = false;
        int stepNo = 0;
        do {
            List<ModelNode> opNodeList = modelNodeList.stream().filter(item ->
                    "parallel,switch,vote,end".contains(item.getNodeType())).collect(Collectors.toList());
            if (opNodeList.size() <= 0) break;

            hasLeastOne = false; // 至少能简化1个图形
            for (ModelNode opNode: opNodeList) {
                // 右边运算符循环
                List<ModelLine> lineToOpNodeList = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(opNode.getPicId())).collect(Collectors.toList());
                List<List<ModelNode>> listPath = new ArrayList<>();
                ModelNode lastNode = null;
                boolean thisNodeSucc= true;
                for (ModelLine modelLine: lineToOpNodeList) {
                    // 右边运算符的逐个路径循环
                    List<ModelNode> result = new ArrayList<>();
                    handleOneLine(modelLineList, modelNodeList, modelLine, result);
                    listPath.add(result);
                    ModelNode curLastNode = result.get(result.size()-1);
                    if (lastNode == null) {
                        lastNode = curLastNode;
                    } else {
                        if (!lastNode.getId().equals(curLastNode.getId())){
                            thisNodeSucc = false;
                            break;
                        }
                    }
                }
                if (thisNodeSucc) {
                    //形成虚节点算法
                    stepNo = replaceToVNode(modelId, modelNodeList, modelLineList, opNode, listPath, lastNode, algoList, stepNo);
                    hasLeastOne = true;
                }
            } // end for
        } while (hasLeastOne);

//        if (saveFlag) saveModel(modelId, modelNodeList, modelLineList, algoList);
    }

    private void handleOneLine(List<ModelLine> modelLineList,
                               List<ModelNode> modelNodeList,
                               ModelLine modelLine,
                               List<ModelNode> result) {
        ModelNode modelNode = modelNodeList.stream().filter(item ->
                item.getPicId().equals(modelLine.getBeginCell())).collect(Collectors.toList()).get(0);
        result.add(modelNode);
        if ("start".equals(modelNode.getNodeType())) {
            return;
        }
        List<ModelLine> lines =modelLineList.stream().filter(item ->
                item.getBeginCell().equals(modelNode.getPicId())).collect(Collectors.toList());
        List<ModelLine> lines2 =modelLineList.stream().filter(item ->
                item.getEndCell().equals(modelNode.getPicId())).collect(Collectors.toList());
        if (lines.size()>1 || lines2.size()>1) {
            return;
        } else {
            handleOneLine(modelLineList, modelNodeList, lines2.get(0), result);
        }
    }

    private int replaceToVNode(Long modelId,
                                List<ModelNode> modelNodeList,
                                List<ModelLine> modelLineList,
                                ModelNode opNode,
                                List<List<ModelNode>> listPath,
                                ModelNode lastNode,
                                List<Algorithm> algoList,
                                int stepNo) {
        String computerList = "";
        String objectList = "";
        for (List<ModelNode> path : listPath) {
            path.remove(path.get(path.size()-1));
            Long id = null;
            String name = "";
            if (path.size()==0) {
                return stepNo;
            } else if (path.size()==1) {
                if ("end".equals(opNode.getNodeType()) && !"start".equals(lastNode.getNodeType())) return stepNo;
                id = path.get(path.size()-1).getId();
                name = path.get(path.size()-1).getName();
            } else {
                id = UUIDUtil.generateId();
                name = id.toString();
                Algorithm algo = new Algorithm();
                algo.setId(id);
                algo.setModelId(modelId);
                algo.setComputerId(id);
                algo.setModelType("series");
                algo.setAlgorithmType("series");
                algo.setComputerList(joinNodeId(path, ","));
                algo.setObjectList(joinNodeName(path, ","));
                algo.setStep(stepNo);
                stepNo++;
                algoList.add(algo);
                name = "v"+ algo.getStep();
            }
            computerList = computerList.equals("") ? id.toString() : computerList + "," + id.toString();
            objectList = objectList.equals("") ? name : objectList + "," + name;
            for (ModelNode node : path) {
                List<ModelLine> lineList4 = modelLineList.stream().filter(item ->
                        item.getEndCell().equals(node.getPicId()) || item.getBeginCell().equals(node.getPicId())).collect(Collectors.toList());
                modelLineList.removeAll(lineList4);
                modelNodeList.remove(node);
            }
        }
        Algorithm algo = new Algorithm();
        Long id = UUIDUtil.generateId();
        algo.setId(id);
        algo.setModelId(modelId);
        algo.setComputerId(id);
        algo.setModelType(opNode.getNodeType());
        algo.setAlgorithmType(opNode.getNodeType());
        algo.setComputerList(computerList);
        algo.setObjectList(objectList);
        algo.setStep(stepNo);
        stepNo++;
        algoList.add(algo);

        //将原运算节点改成虚节点
        opNode.setId(id);
        opNode.setNodeType("vnode");
        opNode.setName("v"+algo.getStep());

        ModelLine modelLineNew = new ModelLine();
        Long picId2 = UUIDUtil.generateId();
        modelLineNew.setId(picId2);
        modelLineNew.setPicId(picId2.toString());
        modelLineNew.setModelId(modelId);
        modelLineNew.setBeginCell(lastNode.getPicId());
        modelLineNew.setEndCell(opNode.getPicId());
        modelLineList.add(modelLineNew);

        return stepNo;
    }

    private String joinNodeId(List<ModelNode> nodeList, String sep) {
        String result = "";
        for (int i = 0; i < nodeList.size(); i++) {
            if (i > 0) result = result + sep;
            result = result + nodeList.get(i).getId().toString();
        }
        return result;
    }

    private String joinNodeName(List<ModelNode> nodeList, String sep) {
        String result = "";
        for (int i = 0; i < nodeList.size(); i++) {
            if (i > 0) result = result + sep;
            result = result + nodeList.get(i).getName();
        }
        return result;
    }
============解析模型的第1版，已不使用============    */

}