codeboss
/
WsParser_VS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1

This commit is contained in:
codeboss 2024-10-08 23:12:10 +08:00
parent ddf9b01651
commit 3abf4c5aea
1 changed files with 96 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
StoryPresent/dag_layout.cpp
View File

@ -3,8 +3,7 @@ using namespace dags;
using namespace graph_data; using namespace graph_data;
DAGLayerHelper::DAGLayerHelper(const Node& bind) DAGLayerHelper::DAGLayerHelper(const Node& bind)
: bind_node(bind) { : bind_node(bind) { }
}
Node DAGLayerHelper::bindPoint() const { Node DAGLayerHelper::bindPoint() const {
return this->bind_node; return this->bind_node;
@ -38,8 +37,7 @@ DAGOrderHelper::DAGOrderHelper(std::shared_ptr<DAGLayerHelper> bind) : layer_bin
} }
DAGOrderHelper::DAGOrderHelper(std::shared_ptr<DAGLayerHelper> f, std::shared_ptr<DAGLayerHelper> t) DAGOrderHelper::DAGOrderHelper(std::shared_ptr<DAGLayerHelper> f, std::shared_ptr<DAGLayerHelper> t)
: relate_bind(f), towards_to(t) { : relate_bind(f), towards_to(t) { }
}
bool DAGOrderHelper::isFakeNode() const { bool DAGOrderHelper::isFakeNode() const {
return !this->layer_bind; return !this->layer_bind;
@ -228,8 +226,7 @@ QList<std::shared_ptr<DAGOrderHelper>> DAGGraph::tidy_graph_nodes() {
} }
#include <QDebug> #include <QDebug>
void dags::DAGGraph::graph_layout_layers_forward(const QList<std::shared_ptr<DAGOrderHelper>>& nodes) void dags::DAGGraph::graph_layout_layers_forward(const QList<std::shared_ptr<DAGOrderHelper>>& nodes) {
{
for (auto layer_index = 0; layer_index < maxLayerCount(); ++layer_index) { for (auto layer_index = 0; layer_index < maxLayerCount(); ++layer_index) {
this->nodes_sort_forward_within_layer(layer_index, nodes); this->nodes_sort_forward_within_layer(layer_index, nodes);
this->nodes_sort_with_above(layer_index, nodes); this->nodes_sort_with_above(layer_index, nodes);
@ -238,7 +235,7 @@ void dags::DAGGraph::graph_layout_layers_forward(const QList<std::shared_ptr<DAG
void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) { void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) {
QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer; QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer;
std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer), std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer),
[=](std::shared_ptr<DAGOrderHelper> ins) { return ins->layerNumber() == layer_index; }); [=](std::shared_ptr<DAGOrderHelper> ins) { return ins->layerNumber() == layer_index; });
if (nodes_within_current_layer.size()) { if (nodes_within_current_layer.size()) {
// 计算当前层次所有节点排序 // 计算当前层次所有节点排序
@ -250,37 +247,36 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList<std:
} }
} }
else if (layer_index > 0) { else if (layer_index > 0) {
QList<std::shared_ptr<DAGOrderHelper>> nodes_fixed; double min_sortv = DBL_MAX;
for (auto target_node : nodes_within_current_layer) { for (auto target_node : nodes_within_current_layer) {
auto upstream_list = target_node->getUpstreamNodes(); auto upstream_list = target_node->getUpstreamNodes();
std::sort(upstream_list.begin(), upstream_list.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); });
if (upstream_list.size()) { if (upstream_list.size()) {
auto sort_anchor = upstream_list[(upstream_list.size() - 1) / 2]; QList<double> sort_values;
target_node->setSortNumber(sort_anchor->sortNumber().toInt()); std::transform(upstream_list.begin(), upstream_list.end(), std::back_inserter(sort_values),
nodes_fixed << sort_anchor; [](std::shared_ptr<DAGOrderHelper> ins) { return ins->sortNumber().toDouble(); });
auto vals_sum = std::accumulate(sort_values.begin(), sort_values.end(), 0.0);
target_node->setSortNumber(vals_sum / sort_values.size());
min_sortv = std::min(target_node->sortNumber().toDouble(), min_sortv);
} }
} }
QList<std::shared_ptr<DAGOrderHelper>> nodes_hangout; QList<std::shared_ptr<DAGOrderHelper>> nodes_hangout;
std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
std::back_inserter(nodes_hangout), [](std::shared_ptr<DAGOrderHelper> ins) { std::back_inserter(nodes_hangout), [](std::shared_ptr<DAGOrderHelper> ins) {
return ins->sortNumber().isNull(); return ins->sortNumber().isNull();
}); });
if (nodes_hangout.size()) { if (nodes_hangout.size()) {
auto min_anchor = std::min_element(nodes_fixed.begin(), nodes_fixed.end(), auto vspan = 1.0 / (nodes_hangout.size() + 1);
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); });
for (int idx = 0; idx < nodes_hangout.size(); ++idx) { for (int idx = 0; idx < nodes_hangout.size(); ++idx) {
nodes_hangout[idx]->setSortNumber((*min_anchor)->sortNumber().toInt() - idx - 1); nodes_hangout[idx]->setSortNumber(min_sortv - (idx + 1) * vspan);
} }
} }
std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->sortNumber() < b->sortNumber(); return a->sortNumber() < b->sortNumber();
}); });
// 提取当前层次节点排序值 // 提取当前层次节点排序值
this->current_nodelist_filling_indi(nodes_within_current_layer); this->current_nodelist_filling_indi(nodes_within_current_layer);
@ -288,14 +284,14 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList<std:
} }
} }
bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<DAGOrderHelper>>& nodes_within_current_layer) bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<DAGOrderHelper>>& nodes_within_current_layer) {
{
// 提取节点划分档次 // 提取节点划分档次
QList<int> ordered_values; QList<int> ordered_values;
std::transform(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::transform(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
std::back_inserter(ordered_values), [=](std::shared_ptr<DAGOrderHelper> ins) { std::back_inserter(ordered_values), [=](std::shared_ptr<DAGOrderHelper> ins) {
return ins->sortNumber().toInt(); return ins->sortNumber().toInt();
}); });
ordered_values = ordered_values.toSet().toList(); ordered_values = ordered_values.toSet().toList();
std::sort(ordered_values.begin(), ordered_values.end()); std::sort(ordered_values.begin(), ordered_values.end());
@ -310,7 +306,7 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<D
QList<std::shared_ptr<DAGOrderHelper>> pick_ups; QList<std::shared_ptr<DAGOrderHelper>> pick_ups;
std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::back_inserter(pick_ups), std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::back_inserter(pick_ups),
[=](std::shared_ptr<DAGOrderHelper> ins) { return ins->sortNumber() >= prev_sortv && ins->sortNumber() < curr_sortv; }); [=](std::shared_ptr<DAGOrderHelper> ins) { return ins->sortNumber() >= prev_sortv && ins->sortNumber() < curr_sortv; });
for (int idx = 0; idx < std::min(curr_sortv - prev_sortv, pick_ups.size()); idx++) { for (int idx = 0; idx < std::min(curr_sortv - prev_sortv, pick_ups.size()); idx++) {
auto target_node = pick_ups[idx]; auto target_node = pick_ups[idx];
@ -329,17 +325,16 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<D
return true; return true;
} }
void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) {
{
// 提取所有已知节点 // 提取所有已知节点
QList<std::shared_ptr<DAGOrderHelper>> sorting_nodes; QList<std::shared_ptr<DAGOrderHelper>> sorting_nodes;
std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(sorting_nodes), std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(sorting_nodes),
[&](std::shared_ptr<DAGOrderHelper> n) { return n->layerNumber() <= layer_index; }); [&](std::shared_ptr<DAGOrderHelper> n) { return n->layerNumber() <= layer_index; });
// 排序值提取与重排 // 排序值提取与重排
QList<double> sort_values; QList<double> sort_values;
std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values), std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values),
[](std::shared_ptr<DAGOrderHelper> n)->double { return n->sortNumber().toDouble(); }); [](std::shared_ptr<DAGOrderHelper> n)->double { return n->sortNumber().toDouble(); });
sort_values = sort_values.toSet().toList(); sort_values = sort_values.toSet().toList();
std::sort(sort_values.begin(), sort_values.end()); std::sort(sort_values.begin(), sort_values.end());
@ -360,8 +355,7 @@ void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList<std::sha
} }
} }
void dags::DAGGraph::graph_adjust_layers_backward(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) void dags::DAGGraph::graph_adjust_layers_backward(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
auto layer_index = this->maxLayerCount() - 1; auto layer_index = this->maxLayerCount() - 1;
while (layer_index > -1) { while (layer_index > -1) {
auto nlist = this->layer_adjust_via_next_sibling(layer_index, total_nodes); auto nlist = this->layer_adjust_via_next_sibling(layer_index, total_nodes);
@ -371,11 +365,10 @@ void dags::DAGGraph::graph_adjust_layers_backward(const QList<std::shared_ptr<DA
}; };
} }
QList<std::shared_ptr<DAGOrderHelper>> dags::DAGGraph::layer_adjust_via_next_sibling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) QList<std::shared_ptr<DAGOrderHelper>> dags::DAGGraph::layer_adjust_via_next_sibling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
QList<std::shared_ptr<DAGOrderHelper>> curr_layer_nodes; QList<std::shared_ptr<DAGOrderHelper>> curr_layer_nodes;
std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(curr_layer_nodes), std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(curr_layer_nodes),
[&](std::shared_ptr<DAGOrderHelper> inst) { return inst->layerNumber() == curr_layer; }); [&](std::shared_ptr<DAGOrderHelper> inst) { return inst->layerNumber() == curr_layer; });
for (auto node : curr_layer_nodes) { for (auto node : curr_layer_nodes) {
this->node_adjust_via_next_sibling(node, total_nodes); this->node_adjust_via_next_sibling(node, total_nodes);
@ -383,74 +376,72 @@ QList<std::shared_ptr<DAGOrderHelper>> dags::DAGGraph::layer_adjust_via_next_sib
std::sort(curr_layer_nodes.begin(), curr_layer_nodes.end(), std::sort(curr_layer_nodes.begin(), curr_layer_nodes.end(),
[](std::shared_ptr<DAGOrderHelper>a, std::shared_ptr<DAGOrderHelper> b)->bool { [](std::shared_ptr<DAGOrderHelper>a, std::shared_ptr<DAGOrderHelper> b)->bool {
auto prevs_a = a->getUpstreamNodes(); auto prevs_a = a->getUpstreamNodes();
auto prevs_b = b->getUpstreamNodes(); auto prevs_b = b->getUpstreamNodes();
if (!prevs_a.size() && !prevs_b.size()) if (!prevs_a.size() && !prevs_b.size())
return a > b; return a > b;
if (!prevs_a.size()) if (!prevs_a.size())
return true; return true;
if (!prevs_b.size()) if (!prevs_b.size())
return false; return false;
auto upnode_a = std::min_element(prevs_a.begin(), prevs_a.end(), auto upnode_a = std::min_element(prevs_a.begin(), prevs_a.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); }); [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); });
auto upnode_b = std::min_element(prevs_b.begin(), prevs_b.end(), auto upnode_b = std::min_element(prevs_b.begin(), prevs_b.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); }); [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); });
return (*upnode_a)->sortNumber() < (*upnode_b)->sortNumber(); return (*upnode_a)->sortNumber() < (*upnode_b)->sortNumber();
}); });
return curr_layer_nodes; return curr_layer_nodes;
} }
void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper> curr_node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper> curr_node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
// 计算下游调整参考节点 // 计算下游调整参考节点
QList<std::shared_ptr<DAGOrderHelper>> next_layer_nodes; QList<std::shared_ptr<DAGOrderHelper>> next_layer_nodes;
std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(next_layer_nodes), std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(next_layer_nodes),
[&](std::shared_ptr<DAGOrderHelper> inst) { [&](std::shared_ptr<DAGOrderHelper> inst) {
if (inst->layerNumber() == curr_node->layerNumber() + 1) { if (inst->layerNumber() == curr_node->layerNumber() + 1) {
if (curr_node->isFakeNode()) { if (curr_node->isFakeNode()) {
if (inst->isFakeNode()) { if (inst->isFakeNode()) {
return curr_node->tailsNode() == inst->tailsNode() && curr_node->headsNode() == inst->headsNode(); return curr_node->tailsNode() == inst->tailsNode() && curr_node->headsNode() == inst->headsNode();
} }
return curr_node->headsNode() == inst->layerNode(); return curr_node->headsNode() == inst->layerNode();
}
else {
if (inst->isFakeNode()) {
return curr_node->layerNode() == inst->tailsNode();
} }
else { else {
auto next_vnodes = curr_node->layerNode()->nextNodes(); if (inst->isFakeNode()) {
return next_vnodes.contains(inst->layerNode()); return curr_node->layerNode() == inst->tailsNode();
}
else {
auto next_vnodes = curr_node->layerNode()->nextNodes();
return next_vnodes.contains(inst->layerNode());
}
} }
} }
} return false;
return false; });
});
std::sort(next_layer_nodes.begin(), next_layer_nodes.end(), std::sort(next_layer_nodes.begin(), next_layer_nodes.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->sortNumber() < b->sortNumber(); return a->sortNumber() < b->sortNumber();
}); });
if (next_layer_nodes.size()) { if (next_layer_nodes.size()) {
curr_node->setSortNumber(next_layer_nodes.first()->sortNumber().toDouble()); curr_node->setSortNumber(next_layer_nodes.first()->sortNumber().toDouble());
} }
} }
void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
// 提取所有已知节点 // 提取所有已知节点
QList<std::shared_ptr<DAGOrderHelper>> sorting_nodes; QList<std::shared_ptr<DAGOrderHelper>> sorting_nodes;
std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(sorting_nodes), std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(sorting_nodes),
[=](std::shared_ptr<DAGOrderHelper> ins) { return ins->layerNumber() >= curr_layer; }); [=](std::shared_ptr<DAGOrderHelper> ins) { return ins->layerNumber() >= curr_layer; });
// 排序值提取与重排 // 排序值提取与重排
QList<double> sort_values; QList<double> sort_values;
std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values), std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values),
[](std::shared_ptr<DAGOrderHelper> n)->double { return n->sortNumber().toDouble(); }); [](std::shared_ptr<DAGOrderHelper> n)->double { return n->sortNumber().toDouble(); });
sort_values = sort_values.toSet().toList(); sort_values = sort_values.toSet().toList();
std::sort(sort_values.begin(), sort_values.end()); std::sort(sort_values.begin(), sort_values.end());
@ -470,8 +461,7 @@ void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList<std::sha
} }
} }
void dags::DAGGraph::node_adjust_ingraph_forward(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) void dags::DAGGraph::node_adjust_ingraph_forward(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
int layer_index = 0; int layer_index = 0;
while (this->nodes_revise_forward_within_layer(layer_index, total_nodes)) { while (this->nodes_revise_forward_within_layer(layer_index, total_nodes)) {
this->node_adjust_inlayer_partition_indi(layer_index, total_nodes); this->node_adjust_inlayer_partition_indi(layer_index, total_nodes);
@ -480,22 +470,21 @@ void dags::DAGGraph::node_adjust_ingraph_forward(const QList<std::shared_ptr<DAG
} }
} }
bool dags::DAGGraph::nodes_revise_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) bool dags::DAGGraph::nodes_revise_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) {
{
if (layer_index) { if (layer_index) {
QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer; QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer;
std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer), std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer),
[=](std::shared_ptr<DAGOrderHelper> n) { return n->layerNumber() == layer_index; }); [=](std::shared_ptr<DAGOrderHelper> n) { return n->layerNumber() == layer_index; });
QList<std::pair<int, int>> sort_arrows; QList<std::pair<int, int>> sort_arrows;
std::for_each(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::for_each(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
[&](std::shared_ptr<DAGOrderHelper> curr_node) { [&](std::shared_ptr<DAGOrderHelper> curr_node) {
auto prev_nodes = curr_node->getUpstreamNodes(); auto prev_nodes = curr_node->getUpstreamNodes();
std::for_each(prev_nodes.begin(), prev_nodes.end(), std::for_each(prev_nodes.begin(), prev_nodes.end(),
[&](std::shared_ptr<DAGOrderHelper> n) { [&](std::shared_ptr<DAGOrderHelper> n) {
sort_arrows << std::make_pair(n->sortNumber().toInt(), curr_node->sortNumber().toInt()); sort_arrows << std::make_pair(n->sortNumber().toInt(), curr_node->sortNumber().toInt());
});
}); });
});
} }
@ -564,18 +553,17 @@ bool dags::DAGGraph::node_adjust_inlayer_forward(int curr_layer, const QList<std
return true; return true;
} }
*/ */
bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) {
{
// 提取层次节点并排序节点 // 提取层次节点并排序节点
QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer; QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer;
std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_current_layer), std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_current_layer),
[=](std::shared_ptr<DAGOrderHelper> inst) { [=](std::shared_ptr<DAGOrderHelper> inst) {
return layer_index == inst->layerNumber(); return layer_index == inst->layerNumber();
}); });
std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->sortNumber() < b->sortNumber(); return a->sortNumber() < b->sortNumber();
}); });
if (!nodes_within_current_layer.size()) if (!nodes_within_current_layer.size())
return false; return false;
@ -589,15 +577,15 @@ bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, const Q
} }
auto anchor_it = std::min_element(prev_nodes.begin(), prev_nodes.end(), auto anchor_it = std::min_element(prev_nodes.begin(), prev_nodes.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->layerNumber() < b->layerNumber(); return a->layerNumber() < b->layerNumber();
}); });
sort_helper.append(std::make_pair(inst, (*anchor_it)->sortNumber())); sort_helper.append(std::make_pair(inst, (*anchor_it)->sortNumber()));
} }
QList<QVariant> sort_backup; QList<QVariant> sort_backup;
std::transform(sort_helper.begin(), sort_helper.end(), std::back_inserter(sort_backup), std::transform(sort_helper.begin(), sort_helper.end(), std::back_inserter(sort_backup),
[](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) { return u.second; }); [](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) { return u.second; });
auto aligned_items_count = std::count_if(sort_backup.begin(), sort_backup.end(), [](QVariant u) { return !u.isNull(); }); auto aligned_items_count = std::count_if(sort_backup.begin(), sort_backup.end(), [](QVariant u) { return !u.isNull(); });
if (!aligned_items_count) if (!aligned_items_count)
@ -639,9 +627,9 @@ bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, const Q
} }
auto val_revised = sub_sum / aligned_items_count; auto val_revised = sub_sum / aligned_items_count;
std::for_each(sort_helper.begin(), sort_helper.end(), std::for_each(sort_helper.begin(), sort_helper.end(),
[=](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) { [=](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) {
u.first->setSortNumber(u.second.toDouble() - val_revised); u.first->setSortNumber(u.second.toDouble() - val_revised);
}); });
this->current_nodelist_filling_indi(nodes_within_current_layer); this->current_nodelist_filling_indi(nodes_within_current_layer);
return true; return true;
@ -747,18 +735,15 @@ void dags::DAGGraph::primitiveGraphLayout() {
this->node_with_layout = tidy_nodes; this->node_with_layout = tidy_nodes;
} }
void dags::DAGGraph::forwardsLayoutImpls() void dags::DAGGraph::forwardsLayoutImpls() {
{
this->graph_layout_layers_forward(this->node_with_layout); this->graph_layout_layers_forward(this->node_with_layout);
} }
void dags::DAGGraph::backwardsLayoutImpls() void dags::DAGGraph::backwardsLayoutImpls() {
{
this->graph_adjust_layers_backward(this->node_with_layout); this->graph_adjust_layers_backward(this->node_with_layout);
} }
void dags::DAGGraph::adjustLayoutImpls() void dags::DAGGraph::adjustLayoutImpls() {
{
//this->node_adjust_ingraph_forward(this->node_with_layout); //this->node_adjust_ingraph_forward(this->node_with_layout);
} }