From 3abf4c5aea223adb97b936a14a814230f35bac2a Mon Sep 17 00:00:00 2001 From: codeboss <2422523675@qq.com> Date: Tue, 8 Oct 2024 23:12:10 +0800 Subject: [PATCH] 1 --- StoryPresent/dag_layout.cpp | 207 +++++++++++++++++------------------- 1 file changed, 96 insertions(+), 111 deletions(-) diff --git a/StoryPresent/dag_layout.cpp b/StoryPresent/dag_layout.cpp index 88b0542..13a8d88 100644 --- a/StoryPresent/dag_layout.cpp +++ b/StoryPresent/dag_layout.cpp @@ -3,8 +3,7 @@ using namespace dags; using namespace graph_data; DAGLayerHelper::DAGLayerHelper(const Node& bind) - : bind_node(bind) { -} + : bind_node(bind) { } Node DAGLayerHelper::bindPoint() const { return this->bind_node; @@ -38,8 +37,7 @@ DAGOrderHelper::DAGOrderHelper(std::shared_ptr bind) : layer_bin } DAGOrderHelper::DAGOrderHelper(std::shared_ptr f, std::shared_ptr t) - : relate_bind(f), towards_to(t) { -} + : relate_bind(f), towards_to(t) { } bool DAGOrderHelper::isFakeNode() const { return !this->layer_bind; @@ -228,8 +226,7 @@ QList> DAGGraph::tidy_graph_nodes() { } #include -void dags::DAGGraph::graph_layout_layers_forward(const QList>& nodes) -{ +void dags::DAGGraph::graph_layout_layers_forward(const QList>& nodes) { for (auto layer_index = 0; layer_index < maxLayerCount(); ++layer_index) { this->nodes_sort_forward_within_layer(layer_index, nodes); this->nodes_sort_with_above(layer_index, nodes); @@ -238,7 +235,7 @@ void dags::DAGGraph::graph_layout_layers_forward(const QList>& nodes) { QList> nodes_within_current_layer; std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer), - [=](std::shared_ptr ins) { return ins->layerNumber() == layer_index; }); + [=](std::shared_ptr ins) { return ins->layerNumber() == layer_index; }); if (nodes_within_current_layer.size()) { // 计算当前层次所有节点排序 @@ -250,37 +247,36 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList 0) { - QList> nodes_fixed; + double min_sortv = DBL_MAX; for (auto target_node : nodes_within_current_layer) { auto upstream_list = target_node->getUpstreamNodes(); - std::sort(upstream_list.begin(), upstream_list.end(), - [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); - if (upstream_list.size()) { - auto sort_anchor = upstream_list[(upstream_list.size() - 1) / 2]; - target_node->setSortNumber(sort_anchor->sortNumber().toInt()); - nodes_fixed << sort_anchor; + QList sort_values; + std::transform(upstream_list.begin(), upstream_list.end(), std::back_inserter(sort_values), + [](std::shared_ptr 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> nodes_hangout; std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), - std::back_inserter(nodes_hangout), [](std::shared_ptr ins) { - return ins->sortNumber().isNull(); - }); + std::back_inserter(nodes_hangout), [](std::shared_ptr ins) { + return ins->sortNumber().isNull(); + }); if (nodes_hangout.size()) { - auto min_anchor = std::min_element(nodes_fixed.begin(), nodes_fixed.end(), - [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); - + auto vspan = 1.0 / (nodes_hangout.size() + 1); 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::shared_ptr a, std::shared_ptr b) { - return a->sortNumber() < b->sortNumber(); - }); + [](std::shared_ptr a, std::shared_ptr b) { + return a->sortNumber() < b->sortNumber(); + }); // 提取当前层次节点排序值 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>& nodes_within_current_layer) -{ +bool dags::DAGGraph::current_nodelist_filling_indi(const QList>& nodes_within_current_layer) { + // 提取节点划分档次 QList ordered_values; std::transform(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), - std::back_inserter(ordered_values), [=](std::shared_ptr ins) { - return ins->sortNumber().toInt(); - }); + std::back_inserter(ordered_values), [=](std::shared_ptr ins) { + return ins->sortNumber().toInt(); + }); ordered_values = ordered_values.toSet().toList(); std::sort(ordered_values.begin(), ordered_values.end()); @@ -310,7 +306,7 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList> pick_ups; std::copy_if(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), std::back_inserter(pick_ups), - [=](std::shared_ptr ins) { return ins->sortNumber() >= prev_sortv && ins->sortNumber() < curr_sortv; }); + [=](std::shared_ptr 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++) { auto target_node = pick_ups[idx]; @@ -329,17 +325,16 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList>& nodes) -{ +void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList>& nodes) { // 提取所有已知节点 QList> sorting_nodes; std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(sorting_nodes), - [&](std::shared_ptr n) { return n->layerNumber() <= layer_index; }); + [&](std::shared_ptr n) { return n->layerNumber() <= layer_index; }); // 排序值提取与重排 QList sort_values; std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values), - [](std::shared_ptr n)->double { return n->sortNumber().toDouble(); }); + [](std::shared_ptr n)->double { return n->sortNumber().toDouble(); }); sort_values = sort_values.toSet().toList(); std::sort(sort_values.begin(), sort_values.end()); @@ -360,8 +355,7 @@ void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList>& total_nodes) -{ +void dags::DAGGraph::graph_adjust_layers_backward(const QList>& total_nodes) { auto layer_index = this->maxLayerCount() - 1; while (layer_index > -1) { 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> dags::DAGGraph::layer_adjust_via_next_sibling(int curr_layer, const QList>& total_nodes) -{ +QList> dags::DAGGraph::layer_adjust_via_next_sibling(int curr_layer, const QList>& total_nodes) { QList> curr_layer_nodes; std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(curr_layer_nodes), - [&](std::shared_ptr inst) { return inst->layerNumber() == curr_layer; }); + [&](std::shared_ptr inst) { return inst->layerNumber() == curr_layer; }); for (auto node : curr_layer_nodes) { this->node_adjust_via_next_sibling(node, total_nodes); @@ -383,74 +376,72 @@ QList> dags::DAGGraph::layer_adjust_via_next_sib std::sort(curr_layer_nodes.begin(), curr_layer_nodes.end(), [](std::shared_ptra, std::shared_ptr b)->bool { - auto prevs_a = a->getUpstreamNodes(); - auto prevs_b = b->getUpstreamNodes(); + auto prevs_a = a->getUpstreamNodes(); + auto prevs_b = b->getUpstreamNodes(); - if (!prevs_a.size() && !prevs_b.size()) - return a > b; - if (!prevs_a.size()) - return true; - if (!prevs_b.size()) - return false; + if (!prevs_a.size() && !prevs_b.size()) + return a > b; + if (!prevs_a.size()) + return true; + if (!prevs_b.size()) + return false; - auto upnode_a = std::min_element(prevs_a.begin(), prevs_a.end(), - [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); - auto upnode_b = std::min_element(prevs_b.begin(), prevs_b.end(), - [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); + auto upnode_a = std::min_element(prevs_a.begin(), prevs_a.end(), + [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); + auto upnode_b = std::min_element(prevs_b.begin(), prevs_b.end(), + [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); - return (*upnode_a)->sortNumber() < (*upnode_b)->sortNumber(); - }); + return (*upnode_a)->sortNumber() < (*upnode_b)->sortNumber(); + }); return curr_layer_nodes; } -void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr curr_node, const QList>& total_nodes) -{ +void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr curr_node, const QList>& total_nodes) { // 计算下游调整参考节点 QList> next_layer_nodes; std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(next_layer_nodes), - [&](std::shared_ptr inst) { - if (inst->layerNumber() == curr_node->layerNumber() + 1) { - if (curr_node->isFakeNode()) { - if (inst->isFakeNode()) { - return curr_node->tailsNode() == inst->tailsNode() && curr_node->headsNode() == inst->headsNode(); - } - return curr_node->headsNode() == inst->layerNode(); - } - else { - if (inst->isFakeNode()) { - return curr_node->layerNode() == inst->tailsNode(); + [&](std::shared_ptr inst) { + if (inst->layerNumber() == curr_node->layerNumber() + 1) { + if (curr_node->isFakeNode()) { + if (inst->isFakeNode()) { + return curr_node->tailsNode() == inst->tailsNode() && curr_node->headsNode() == inst->headsNode(); + } + return curr_node->headsNode() == inst->layerNode(); } else { - auto next_vnodes = curr_node->layerNode()->nextNodes(); - return next_vnodes.contains(inst->layerNode()); + if (inst->isFakeNode()) { + 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::shared_ptr a, std::shared_ptr b) { - return a->sortNumber() < b->sortNumber(); - }); + [](std::shared_ptr a, std::shared_ptr b) { + return a->sortNumber() < b->sortNumber(); + }); if (next_layer_nodes.size()) { curr_node->setSortNumber(next_layer_nodes.first()->sortNumber().toDouble()); } } -void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList>& total_nodes) -{ +void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList>& total_nodes) { // 提取所有已知节点 QList> sorting_nodes; std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(sorting_nodes), - [=](std::shared_ptr ins) { return ins->layerNumber() >= curr_layer; }); + [=](std::shared_ptr ins) { return ins->layerNumber() >= curr_layer; }); // 排序值提取与重排 QList sort_values; std::transform(sorting_nodes.begin(), sorting_nodes.end(), std::back_inserter(sort_values), - [](std::shared_ptr n)->double { return n->sortNumber().toDouble(); }); + [](std::shared_ptr n)->double { return n->sortNumber().toDouble(); }); sort_values = sort_values.toSet().toList(); std::sort(sort_values.begin(), sort_values.end()); @@ -470,8 +461,7 @@ void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList>& total_nodes) -{ +void dags::DAGGraph::node_adjust_ingraph_forward(const QList>& total_nodes) { int layer_index = 0; while (this->nodes_revise_forward_within_layer(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>& nodes) -{ +bool dags::DAGGraph::nodes_revise_forward_within_layer(int layer_index, const QList>& nodes) { if (layer_index) { QList> nodes_within_current_layer; std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer), - [=](std::shared_ptr n) { return n->layerNumber() == layer_index; }); + [=](std::shared_ptr n) { return n->layerNumber() == layer_index; }); QList> sort_arrows; - std::for_each(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), - [&](std::shared_ptr curr_node) { - auto prev_nodes = curr_node->getUpstreamNodes(); - std::for_each(prev_nodes.begin(), prev_nodes.end(), - [&](std::shared_ptr n) { - sort_arrows << std::make_pair(n->sortNumber().toInt(), curr_node->sortNumber().toInt()); + std::for_each(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), + [&](std::shared_ptr curr_node) { + auto prev_nodes = curr_node->getUpstreamNodes(); + std::for_each(prev_nodes.begin(), prev_nodes.end(), + [&](std::shared_ptr n) { + 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>& total_nodes) -{ +bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, const QList>& total_nodes) { // 提取层次节点并排序节点 QList> nodes_within_current_layer; std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_current_layer), - [=](std::shared_ptr inst) { - return layer_index == inst->layerNumber(); - }); + [=](std::shared_ptr inst) { + return layer_index == inst->layerNumber(); + }); std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(), - [](std::shared_ptr a, std::shared_ptr b) { - return a->sortNumber() < b->sortNumber(); - }); + [](std::shared_ptr a, std::shared_ptr b) { + return a->sortNumber() < b->sortNumber(); + }); if (!nodes_within_current_layer.size()) 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(), - [](std::shared_ptr a, std::shared_ptr b) { - return a->layerNumber() < b->layerNumber(); - }); + [](std::shared_ptr a, std::shared_ptr b) { + return a->layerNumber() < b->layerNumber(); + }); sort_helper.append(std::make_pair(inst, (*anchor_it)->sortNumber())); } QList sort_backup; std::transform(sort_helper.begin(), sort_helper.end(), std::back_inserter(sort_backup), - [](std::pair, QVariant> u) { return u.second; }); + [](std::pair, QVariant> u) { return u.second; }); auto aligned_items_count = std::count_if(sort_backup.begin(), sort_backup.end(), [](QVariant u) { return !u.isNull(); }); 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; std::for_each(sort_helper.begin(), sort_helper.end(), - [=](std::pair, QVariant> u) { - u.first->setSortNumber(u.second.toDouble() - val_revised); - }); + [=](std::pair, QVariant> u) { + u.first->setSortNumber(u.second.toDouble() - val_revised); + }); this->current_nodelist_filling_indi(nodes_within_current_layer); return true; @@ -747,18 +735,15 @@ void dags::DAGGraph::primitiveGraphLayout() { this->node_with_layout = tidy_nodes; } -void dags::DAGGraph::forwardsLayoutImpls() -{ +void dags::DAGGraph::forwardsLayoutImpls() { 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); } -void dags::DAGGraph::adjustLayoutImpls() -{ +void dags::DAGGraph::adjustLayoutImpls() { //this->node_adjust_ingraph_forward(this->node_with_layout); }