diff --git a/StoryPresent/dag_layout.cpp b/StoryPresent/dag_layout.cpp index 88b0542..cc171e9 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()) { // 计算当前层次所有节点排序 @@ -254,7 +251,7 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QListgetUpstreamNodes(); std::sort(upstream_list.begin(), upstream_list.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 (upstream_list.size()) { auto sort_anchor = upstream_list[(upstream_list.size() - 1) / 2]; @@ -265,12 +262,12 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const 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(); }); + [](std::shared_ptr a, std::shared_ptr b) { return a->sortNumber() < b->sortNumber(); }); for (int idx = 0; idx < nodes_hangout.size(); ++idx) { nodes_hangout[idx]->setSortNumber((*min_anchor)->sortNumber().toInt() - idx - 1); @@ -278,9 +275,9 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList 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 +285,13 @@ 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,102 +470,51 @@ void dags::DAGGraph::node_adjust_ingraph_forward(const QList>& nodes) -{ +bool dags::DAGGraph::nodes_revise_forward_within_layer(int layer_index, const QList>& total_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; }); - - 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()); + QList> nodes_within_previous_layer; + std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_previous_layer), + [=](std::shared_ptr n) { return n->layerNumber() == layer_index - 1; }); + std::sort(nodes_within_previous_layer.begin(), nodes_within_previous_layer.end(), + [](std::shared_ptr a, std::shared_ptr b) { + return a->sortNumber() < b->sortNumber(); }); - }); + + QList> nodes_within_current_layer; + std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_current_layer), + [=](std::shared_ptr n) { return n->layerNumber() == layer_index; }); + 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(); + }); + + //for (int idx = 0; idx < nodes_within_current_layer.size(); ++idx) { + // auto ns_remains = nodes_within_current_layer; + // auto ns_currs = nodes_within_current_layer + // // 调整测试 + // for(auto adj_idx=0; adj_idx>& 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; }); - - if (!curr_layer_nodes.size()) - return false; - - // 计算排序系数 - QList, qlonglong, qlonglong, qlonglong, qlonglong>> orders_helper; - std::transform(curr_layer_nodes.begin(), curr_layer_nodes.end(), std::back_inserter(orders_helper), - [&](std::shared_ptr ins) { - auto val_p = this->node_evaluate_with_upstream(ins, total_nodes); - auto val_n = this->node_evaluate_with_downstream(ins, total_nodes); - return std::make_tuple(ins, val_n.first, val_n.second, val_p.first, val_p.second); - }); - - // 排序当前层次节点 - std::sort(orders_helper.begin(), orders_helper.end(), []( - std::tuple, qlonglong, qlonglong, qlonglong, qlonglong> a, - std::tuple, qlonglong, qlonglong, qlonglong, qlonglong> b) - { - auto prev_nodesa = std::get<0>(a)->getUpstreamNodes(); - auto prev_nodesb = std::get<0>(b)->getUpstreamNodes(); - if (!prev_nodesa.size() && !prev_nodesb.size()) - return a < b; - - if (prev_nodesa.size() && prev_nodesb.size()) { - if (std::get<3>(a) == std::get<3>(b)) { - if (std::get<4>(a) == std::get<4>(b)) { - if (std::get<1>(a) == std::get<1>(b)) { - return std::get<2>(a) < std::get<2>(b); - } - return std::get<1>(a) < std::get<1>(b); - } - return std::get<4>(a) < std::get<4>(b); - } - return std::get<3>(a) < std::get<3>(b); - } - - if (prev_nodesa.size()) { - return false; - } - return true; - }); - - QList sort_values; - std::transform(curr_layer_nodes.begin(), curr_layer_nodes.end(), std::back_inserter(sort_values), - [](std::shared_ptr ins) { return ins->sortNumber().toInt(); }); - std::sort(sort_values.begin(), sort_values.end()); - - // 重新设定节点次序 - for (auto idx = 0; idx < sort_values.size(); ++idx) { - std::get<0>(orders_helper[idx])->setSortNumber(sort_values[idx]); - } - - return true; +int dags::DAGGraph::forks_evaluate_with_sequence(const QList>& prevs, const QList>& currs) { + return 0; } -*/ -bool dags::DAGGraph::node_adjust_inlayer_partition_indi(int layer_index, 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 +528,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,13 +578,14 @@ 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; } + /* std::pair dags::DAGGraph::node_evaluate_with_downstream(std::shared_ptr curr_node, const QList>& total_nodes) { @@ -747,19 +687,16 @@ 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() -{ - //this->node_adjust_ingraph_forward(this->node_with_layout); +void dags::DAGGraph::adjustLayoutImpls() { + this->node_adjust_ingraph_forward(this->node_with_layout); } diff --git a/StoryPresent/dag_layout.h b/StoryPresent/dag_layout.h index ec9c9a4..45b304b 100644 --- a/StoryPresent/dag_layout.h +++ b/StoryPresent/dag_layout.h @@ -104,12 +104,7 @@ namespace dags { void node_adjust_ingraph_forward(const QList>& total_nodes); bool nodes_revise_forward_within_layer(int layer_index, const QList>& nodes); + int forks_evaluate_with_sequence(const QList>& prevs, const QList>& currs); bool node_adjust_inlayer_partition_indi(int layer_index, const QList>& total_nodes); - - - //bool node_adjust_inlayer_forward(int curr_layer, const QList>& total_nodes); - //std::pair node_evaluate_with_downstream(std::shared_ptr node, const QList>& total_nodes); - //std::pair node_evaluate_with_upstream(std::shared_ptr node, const QList>& total_nodes); - }; }