package com.zt.life.modules.mainPart.taskReliability.service;
|
|
import cn.hutool.json.JSONArray;
|
import cn.hutool.json.JSONObject;
|
import com.zt.common.service.BaseService;
|
import com.zt.common.utils.JsonUtils2;
|
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.ProductImg;
|
import com.zt.life.modules.mainPart.taskReliability.dao.*;
|
import com.zt.life.modules.mainPart.taskReliability.model.*;
|
import org.apache.commons.lang3.StringUtils;
|
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.util.*;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* model_line
|
*
|
* @author zt generator
|
* @since 1.0.0 2024-02-28
|
*/
|
@Service
|
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
|
private ModelNodeDao modelNodeDao;
|
@Autowired
|
private ModelRbdDao modelRbdDao;
|
@Autowired
|
private AlgorithmDao algorithmDao;
|
@Autowired
|
private ModelNodeAlgorithmDao modelNodeAlgorithmDao;
|
@Autowired
|
private XhProductModelDao xhProductModelDao;
|
@Autowired
|
private ParamDataDao paramDataDao;
|
|
/**
|
* 分页查询
|
*
|
* @param queryFilter
|
* @return
|
*/
|
public List<ModelLine> page(QueryFilter queryFilter) {
|
return baseDao.getList(queryFilter.getQueryParams());
|
}
|
|
public ModelRbd getDiagram(Long modelId) {
|
return modelRbdDao.getDiagram(modelId);
|
}
|
|
/**
|
* 删除
|
*
|
* @param ids
|
*/
|
public void delete(Long[] ids) {
|
super.deleteLogic(ids);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void insert(ModelRbd modelRbd) {
|
if (modelRbd == null) return;
|
if (modelRbd.getId() == null) return;
|
Long modelId = modelRbd.getId();
|
|
// 删除既有数据
|
modelRbdDao.deleteByModelId(modelId);
|
|
// 插入数据
|
modelRbd.setId(UUIDUtil.generateId());
|
modelRbdDao.insert(modelRbd);
|
}
|
|
|
@Transactional(rollbackFor = Exception.class)
|
public void update(ModelRbd modelRbd) {
|
if (modelRbd == null) return;
|
if (modelRbd.getId() == null) return;
|
Long modelId = modelRbd.getId();
|
|
// 删除既有数据
|
modelRbdDao.deleteByModelId(modelId);
|
|
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;
|
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 = 120;
|
double lineHeight = 90;
|
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/deviceNo".split("/"));
|
if (jsonValue != null && StringUtils.isNotBlank(jsonValue.toString())) {
|
modelNode.setDeviceNo(Integer.valueOf(jsonValue.toString()));
|
} else {
|
modelNode.setDeviceNo(0);
|
}
|
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.setDeviceNo(node.getDeviceNo());
|
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;
|
}
|
|
private boolean analyzeRbd(ModelRbd modelRbd, boolean saveFlag) {
|
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<>(); // 暂不使用（而使用数据库中的可靠性参数）
|
List<ModelNode> modelNodeAndVnodeList = new ArrayList<>();
|
|
// 1. 解析出节点与边
|
getNodeAndLineFromRbd(modelRbd.getId(), rbdJsonArray, modelNodeList, modelLineList, productImgList);
|
// 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 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.setDeviceNo(root.getDeviceNo());
|
node.setNodeType(root.getNodeType());
|
node.setName(root.getName());
|
node.setVoteNum(root.getVoteNum());
|
modelNodeAndVnodeList.add(node);
|
} else {
|
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);
|
}
|
}
|
}
|
|
/**
|
* 对树形结构进行预处理，包括：
|
* 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);
|
}
|
}
|
|
/**
|
* 对树形结构进行预处理：
|
* 去掉逻辑运算块中用于排版的外层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));
|
}
|
deleteSeriesForAutoArrange(children.get(i));
|
}
|
}
|
|
/**
|
* 用于自动排版：将桥联转换为3支路的并联
|
* @param root
|
* @return
|
*/
|
private void convertBridgeToThreeBranchParallel(RbdTreeNode root) {
|
List<RbdTreeNode> children = root.getChildren();
|
for (RbdTreeNode treeNode : children) {
|
if ("bridge".equals(treeNode.getAlgorithmType())) {
|
treeNode.setAlgorithmType("parallel");
|
List<RbdTreeNode> list = new ArrayList<>();
|
RbdTreeNode subNode = new RbdTreeNode();
|
subNode.setAlgorithmType("series");
|
subNode.setId(UUIDUtil.generateId());
|
subNode.setName("v10000");
|
subNode.setNodeType("vnode");
|
subNode.getChildren().add(treeNode.getChildren().get(0));
|
subNode.getChildren().add(treeNode.getChildren().get(1));
|
list.add(subNode);
|
list.add(treeNode.getChildren().get(2));
|
subNode = new RbdTreeNode();
|
subNode.setAlgorithmType("series");
|
subNode.setId(UUIDUtil.generateId());
|
subNode.setName("v10001");
|
subNode.setNodeType("vnode");
|
subNode.getChildren().add(treeNode.getChildren().get(3));
|
subNode.getChildren().add(treeNode.getChildren().get(4));
|
list.add(subNode);
|
treeNode.setChildren(list);
|
}
|
convertBridgeToThreeBranchParallel(treeNode);
|
}
|
}
|
|
/*
|
private void 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);
|
}
|
}
|
|
}
|
*/
|
|
}
|
