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

Compare commits

base: codeboss:ddf9b01651e34241a5241ee0e312ed1c02cee362
Branches Tags
codeboss:master
codeboss:dev
..
compare: codeboss:60073251ab9493f74bec4c24359139fec04ab433
Branches Tags
codeboss:master
codeboss:dev

9 Commits
ddf9b01651 ... 60073251ab

Author SHA1 Message Date
codeboss 60073251ab 1 2024-10-13 19:05:19 +08:00
codeboss c42c399e78 1 2024-10-13 18:51:39 +08:00
codeboss 0819987eb1 1 2024-10-13 16:54:22 +08:00
codeboss c696c0d1d2 1 2024-10-13 16:54:16 +08:00
codeboss 97cd475c7f 1 2024-10-10 21:40:39 +08:00
codeboss 829868be1c 1 2024-10-09 21:03:42 +08:00
codeboss 88b7834e65 1 2024-10-08 23:27:21 +08:00
codeboss 3abf4c5aea 1 2024-10-08 23:12:10 +08:00
codeboss 406d4c733e 1 2024-10-08 22:15:47 +08:00
3 changed files with 59 additions and 319 deletions
Show Stats Expand all files Collapse all files

360
StoryPresent/dag_layout.cpp
View File

@ -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<DAGLayerHelper> bind) : layer_bin
}
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 {
return !this->layer_bind;
@ -228,8 +226,7 @@ QList<std::shared_ptr<DAGOrderHelper>> DAGGraph::tidy_graph_nodes() {
}
#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) {
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<std::shared_ptr<DAG
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;
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()) {
// 计算当前层次所有节点排序
@ -250,35 +247,34 @@ void DAGGraph::nodes_sort_forward_within_layer(int layer_index, const QList<std:
}
}
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) {
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()) {
auto sort_anchor = upstream_list[(upstream_list.size() - 1) / 2];
target_node->setSortNumber(sort_anchor->sortNumber().toInt());
nodes_fixed << sort_anchor;
QList<double> sort_values;
std::transform(upstream_list.begin(), upstream_list.end(), std::back_inserter(sort_values),
[](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;
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();
});
if (nodes_hangout.size()) {
auto min_anchor = std::min_element(nodes_fixed.begin(), nodes_fixed.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> 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<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->sortNumber() < b->sortNumber();
});
@ -288,18 +284,21 @@ 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;
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();
});
ordered_values = ordered_values.toSet().toList();
std::sort(ordered_values.begin(), ordered_values.end());
if (ordered_values.size() == nodes_within_current_layer.size())
//if (ordered_values.size() == nodes_within_current_layer.size())
// return false;
if (!ordered_values.size())
return false;
// 填缝
@ -310,7 +309,7 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<D
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::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++) {
auto target_node = pick_ups[idx];
@ -329,17 +328,16 @@ bool dags::DAGGraph::current_nodelist_filling_indi(const QList<std::shared_ptr<D
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;
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;
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();
std::sort(sort_values.begin(), sort_values.end());
@ -360,8 +358,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;
while (layer_index > -1) {
auto nlist = this->layer_adjust_via_next_sibling(layer_index, total_nodes);
@ -371,11 +368,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;
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) {
this->node_adjust_via_next_sibling(node, total_nodes);
@ -383,33 +379,32 @@ QList<std::shared_ptr<DAGOrderHelper>> dags::DAGGraph::layer_adjust_via_next_sib
std::sort(curr_layer_nodes.begin(), curr_layer_nodes.end(),
[](std::shared_ptr<DAGOrderHelper>a, std::shared_ptr<DAGOrderHelper> 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<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(),
[](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;
}
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;
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 (curr_node->isFakeNode()) {
if (inst->isFakeNode()) {
@ -431,7 +426,7 @@ void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper
});
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();
});
@ -440,17 +435,16 @@ void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper
}
}
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;
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;
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();
std::sort(sort_values.begin(), sort_values.end());
@ -470,256 +464,9 @@ 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)
{
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);
this->nodes_sort_with_above(layer_index, total_nodes);
layer_index++;
}
}
bool dags::DAGGraph::nodes_revise_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes)
{
if (layer_index) {
QList<std::shared_ptr<DAGOrderHelper>> 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; });
QList<std::pair<int, int>> sort_arrows;
std::for_each(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
[&](std::shared_ptr<DAGOrderHelper> curr_node) {
auto prev_nodes = curr_node->getUpstreamNodes();
std::for_each(prev_nodes.begin(), prev_nodes.end(),
[&](std::shared_ptr<DAGOrderHelper> n) {
sort_arrows << std::make_pair(n->sortNumber().toInt(), curr_node->sortNumber().toInt());
});
});
}
return true;
}
/*
bool dags::DAGGraph::node_adjust_inlayer_forward(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_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::shared_ptr<DAGOrderHelper> inst) { return inst->layerNumber() == curr_layer; });
if (!curr_layer_nodes.size())
return false;
// 计算排序系数
QList<std::tuple<std::shared_ptr<DAGOrderHelper>, qlonglong, qlonglong, qlonglong, qlonglong>> orders_helper;
std::transform(curr_layer_nodes.begin(), curr_layer_nodes.end(), std::back_inserter(orders_helper),
[&](std::shared_ptr<DAGOrderHelper> 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<std::shared_ptr<DAGOrderHelper>, qlonglong, qlonglong, qlonglong, qlonglong> a,
std::tuple<std::shared_ptr<DAGOrderHelper>, 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<int> sort_values;
std::transform(curr_layer_nodes.begin(), curr_layer_nodes.end(), std::back_inserter(sort_values),
[](std::shared_ptr<DAGOrderHelper> 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;
}
*/
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;
std::copy_if(total_nodes.begin(), total_nodes.end(), std::back_inserter(nodes_within_current_layer),
[=](std::shared_ptr<DAGOrderHelper> inst) {
return layer_index == inst->layerNumber();
});
std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->sortNumber() < b->sortNumber();
});
if (!nodes_within_current_layer.size())
return false;
// 获取布局系数
QList<std::pair<std::shared_ptr<DAGOrderHelper>, QVariant>> sort_helper;
for (auto& inst : nodes_within_current_layer) {
auto prev_nodes = inst->getUpstreamNodes();
if (!prev_nodes.size()) {
sort_helper.append(std::make_pair(inst, QVariant()));
continue;
}
auto anchor_it = std::min_element(prev_nodes.begin(), prev_nodes.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
return a->layerNumber() < b->layerNumber();
});
sort_helper.append(std::make_pair(inst, (*anchor_it)->sortNumber()));
}
QList<QVariant> 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; });
auto aligned_items_count = std::count_if(sort_backup.begin(), sort_backup.end(), [](QVariant u) { return !u.isNull(); });
if (!aligned_items_count)
return false;
// 补全布局系数
QVariant start_value;
for (auto idx = 0; idx < sort_helper.size(); ++idx) {
auto curr_u = sort_helper[idx];
if (!curr_u.second.isNull()) {
start_value = curr_u.second;
if (idx > 0) {
auto u = sort_helper[0];
sort_helper[0] = std::make_pair(u.first, start_value.toInt() - 1);
}
break;
}
}
for (int idx = 1; idx < sort_helper.size(); ++idx) {
auto prev_u = sort_helper[idx - 1];
auto curr_u = sort_helper[idx];
if (curr_u.second.isNull()) {
sort_helper[idx] = std::make_pair(curr_u.first, prev_u.second);
}
if (curr_u.second < prev_u.second) {
sort_helper[idx] = std::make_pair(curr_u.first, prev_u.second);
}
}
double sub_sum = 0;
// 计算修正系数
for (auto ndx = 0; ndx < sort_backup.size(); ndx++) {
auto valbk = sort_backup[ndx];
auto val2 = sort_helper[ndx].second;
if (!valbk.isNull()) {
sub_sum += val2.toDouble() - valbk.toDouble();
}
}
auto val_revised = sub_sum / aligned_items_count;
std::for_each(sort_helper.begin(), sort_helper.end(),
[=](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) {
u.first->setSortNumber(u.second.toDouble() - val_revised);
});
this->current_nodelist_filling_indi(nodes_within_current_layer);
return true;
}
/*
std::pair<qlonglong, qlonglong> dags::DAGGraph::node_evaluate_with_downstream(std::shared_ptr<DAGOrderHelper> curr_node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
{
decltype(curr_node) next_node;
if (curr_node->isFakeNode()) {
auto n_data = curr_node->headsNode();
next_node = *std::find_if(total_nodes.begin(), total_nodes.end(), [&](decltype(curr_node) n) {
if (!n->isFakeNode()) {
return n->layerNode() == n_data;
}
return false;
});
}
else {
auto n_datas = curr_node->layerNode()->nextNodes();
if (!n_datas.size())
return std::make_pair(curr_node->layerNumber(), curr_node->sortNumber().toLongLong());
QList<std::shared_ptr<DAGOrderHelper>> next_nodes;
std::transform(n_datas.begin(), n_datas.end(), std::back_inserter(next_nodes),
[&](std::shared_ptr<DAGLayerHelper> inst) {
auto rst = std::find_if(total_nodes.begin(), total_nodes.end(), [&](decltype(curr_node) n) {
if (!n->isFakeNode()) {
return n->layerNode() == inst;
}
return false;
});
return *rst;
});
next_node = *std::min_element(next_nodes.begin(), next_nodes.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
if (a->layerNumber() == b->layerNumber())
return a->sortNumber() < b->sortNumber();
return a->layerNumber() < b->layerNumber();
});
}
return std::make_pair(next_node->layerNumber(), next_node->sortNumber().toLongLong());
}
std::pair<qlonglong, qlonglong> dags::DAGGraph::node_evaluate_with_upstream(std::shared_ptr<DAGOrderHelper> curr_node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
{
auto prim_nodes = curr_node->getUpstreamNodes();
if (!prim_nodes.size())
return std::make_pair(curr_node->layerNumber(), curr_node->sortNumber().toLongLong());
QList<std::shared_ptr<DAGOrderHelper>> prev_nodes;
std::transform(prim_nodes.begin(), prim_nodes.end(), std::back_inserter(prev_nodes),
[&](std::shared_ptr<DAGOrderHelper> ins) {
if (!ins->isFakeNode()) {
return ins;
}
auto prev_data = ins->tailsNode();
auto target_it = std::find_if(total_nodes.begin(), total_nodes.end(),
[&](std::shared_ptr<DAGOrderHelper> nins) {
if (!nins->isFakeNode())
return nins->layerNode() == prev_data;
return false;
});
return *target_it;
});
auto prev_it = std::min_element(prev_nodes.begin(), prev_nodes.end(),
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
if (a->layerNumber() == b->layerNumber())
return a->sortNumber() < b->sortNumber();
return a->layerNumber() < b->layerNumber();
});
return std::make_pair((*prev_it)->layerNumber(), (*prev_it)->sortNumber().toLongLong());
}
*/
void dags::DAGGraph::primitiveGraphLayout() {
QList<std::shared_ptr<DAGLayerHelper>> sort_seqs;
QList<std::shared_ptr<DAGLayerHelper>> refs;
@ -747,19 +494,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() {
}

8
StoryPresent/dag_layout.h
View File

@ -102,14 +102,6 @@ namespace dags {
void nodes_sort_with_above(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void nodes_sort_with_belows(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void node_adjust_ingraph_forward(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
bool nodes_revise_forward_within_layer(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes);
bool node_adjust_inlayer_partition_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//bool node_adjust_inlayer_forward(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//std::pair<qlonglong, qlonglong> node_evaluate_with_downstream(std::shared_ptr<DAGOrderHelper> node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//std::pair<qlonglong, qlonglong> node_evaluate_with_upstream(std::shared_ptr<DAGOrderHelper> node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
};
}

10
StoryPresent/storypresent.cpp
View File

@ -20,7 +20,7 @@ StoryPresent::StoryPresent(QWidget* parent)
auto layout = mbar->addMenu(u8"²¼¾Öµ÷Õû");
layout->addAction(u8"ÕýÏò²¼¾Ö", this, &StoryPresent::forwardLayout, Qt::CTRL + Qt::Key_F);
layout->addAction(u8"ÄæÏò²¼¾Ö", this, &StoryPresent::backwardLayout, Qt::CTRL + Qt::Key_B);
//layout->addAction(u8"µ÷Õû²¼¾Ö", this, &StoryPresent::adjustLayout, Qt::CTRL+Qt::Key_A);
layout->addAction(u8"µ÷Õû²¼¾Ö", this, &StoryPresent::adjustLayout, Qt::CTRL+Qt::Key_A);
connect(_story_present, &DAGActiveView::nodeClicked, this, &StoryPresent::nodeClickAccept);
}
@ -122,10 +122,14 @@ void StoryPresent::nodeClickAccept(const QPointF& pos, const QString& node_name)
return;
}
QList<std::shared_ptr<IElementSlice>> parent_slices;
std::transform(refers.begin(), refers.end(), std::back_inserter(parent_slices),
QList<std::shared_ptr<IElementSlice>> vparent_slices;
std::transform(refers.begin(), refers.end(), std::back_inserter(vparent_slices),
[](std::shared_ptr<IElementSlice> ins) { return ins->parentSlice().lock(); });
QList<std::shared_ptr<IElementSlice>> parent_slices;
std::copy_if(vparent_slices.begin(), vparent_slices.end(), std::back_inserter(parent_slices),
[](std::shared_ptr<IElementSlice> ins) -> bool { return ins != nullptr; });
decltype(parent_slices) fliter_slices;
std::copy_if(parent_slices.begin(), parent_slices.end(), std::back_inserter(fliter_slices),
[](std::shared_ptr<IElementSlice> ins) { return ins->type() == SliceType::StoryDefines; });