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

helf

This commit is contained in:
codeboss 2024-10-06 16:03:19 +08:00
parent dd6398223c
commit 5661ba80e8
4 changed files with 178 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
StoryPresent/dag_layout.cpp
View File

@ -270,16 +270,21 @@ void DAGGraph::graph_layer_nodes_sort_forward(int layer_index, const QList<std::
}
}
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();
});
// 提取当前层次节点排序值
this->current_nodelist_filling_indi(layer_index, nodes);
this->current_nodelist_filling_indi(nodes_within_current_layer);
}
this->nodes_sort_with_above(layer_index, nodes);
this->graph_layer_nodes_sort_forward(layer_index + 1, nodes);
}
}
bool dags::DAGGraph::current_nodelist_filling_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes)
/*
bool dags::DAGGraph::current_layer_filling_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes)
{
// 提取本层次节点
QList<std::shared_ptr<DAGOrderHelper>> nodes_within_current_layer;
@ -308,6 +313,11 @@ bool dags::DAGGraph::current_nodelist_filling_indi(int layer_index, const QList<
return (*upnode_a)->sortNumber() < (*upnode_b)->sortNumber();
});
this->current_nodelist_filling_indi(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(),
@ -376,20 +386,25 @@ void dags::DAGGraph::nodes_sort_with_above(int layer_index, const QList<std::sha
auto sort_idx = sort_values.indexOf(node_sortv);
node->setSortNumber(sort_idx - temp_anchor.second);
}
//for (auto n : sorting_nodes) {
// qDebug() << n->layerNumber() << n->sortNumber().toDouble();
//}
//qDebug() << "==============================";
}
void dags::DAGGraph::graph_adjust_after_layout(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
{
auto layer_index = this->maxLayerCount() - 1;
while (layer_index > -1) {
this->layer_adjust_via_next_sibling(layer_index, total_nodes);
if (this->current_nodelist_filling_indi(layer_index, total_nodes))
auto nlist = this->layer_adjust_via_next_sibling(layer_index, total_nodes);
if (this->current_nodelist_filling_indi(nlist))
this->nodes_sort_with_belows(layer_index, total_nodes);
layer_index--;
};
}
bool 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),
@ -399,7 +414,27 @@ bool dags::DAGGraph::layer_adjust_via_next_sibling(int curr_layer, const QList<s
this->node_adjust_via_next_sibling(node, total_nodes);
}
return curr_layer;
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();
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(); });
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(); });
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)
@ -474,6 +509,11 @@ void dags::DAGGraph::node_adjust_ingraph_forward(const QList<std::shared_ptr<DAG
while (this->node_adjust_inlayer_forward(layer_index, total_nodes)) {
layer_index++;
}
for (auto idx = 0; idx < layer_index; ++idx) {
this->sort_index_partition_indi(idx, total_nodes);
this->nodes_sort_with_above(idx, total_nodes);
}
}
bool dags::DAGGraph::node_adjust_inlayer_forward(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
@ -487,18 +527,28 @@ bool dags::DAGGraph::node_adjust_inlayer_forward(int curr_layer, const QList<std
return false;
// 计算排序系数
QList<std::tuple<std::shared_ptr<DAGOrderHelper>, qlonglong, qlonglong>> orders_helper;
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 = this->node_evaluate_with_downstream(ins, total_nodes);
return std::make_tuple(ins, val.first, val.second);
auto val_n = this->node_evaluate_with_downstream(ins, total_nodes);
auto val_p = this->node_evaluate_with_upstream(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> a, std::tuple<std::shared_ptr<DAGOrderHelper>, qlonglong, qlonglong> b) {
if (std::get<1>(a) == std::get<1>(b))
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)
{
if (std::get<1>(a) == std::get<1>(b)) {
if (std::get<2>(a) == std::get<2>(b)) {
if (std::get<3>(a) == std::get<3>(b)) {
return std::get<4>(a) < std::get<4>(b);
}
return std::get<3>(a) < std::get<3>(b);
}
return std::get<2>(a) < std::get<2>(b);
}
return std::get<1>(a) < std::get<1>(b);
});
@ -516,6 +566,75 @@ bool dags::DAGGraph::node_adjust_inlayer_forward(int curr_layer, const QList<std
return true;
}
bool dags::DAGGraph::sort_index_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(*anchor_it, (*anchor_it)->sortNumber()));
}
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;
}
}
if (start_value.isNull())
return false;
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);
}
}
std::for_each(sort_helper.begin(), sort_helper.end(),
[](std::pair<std::shared_ptr<DAGOrderHelper>, QVariant> u) {
u.first->setSortNumber(u.second.toDouble());
});
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> node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
{
decltype(node) next_node;
@ -555,6 +674,40 @@ std::pair<qlonglong, qlonglong> dags::DAGGraph::node_evaluate_with_downstream(st
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> node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes)
{
auto prim_nodes = node->getUpstreamNodes();
if (!prim_nodes.size())
return std::make_pair(node->layerNumber(), 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;

7
StoryPresent/dag_layout.h
View File

@ -93,15 +93,17 @@ namespace dags {
void graph_layer_nodes_sort_forward(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>> &nodes);
void graph_adjust_after_layout(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
bool layer_adjust_via_next_sibling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
QList<std::shared_ptr<DAGOrderHelper>> layer_adjust_via_next_sibling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper> curr_node, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
bool current_nodelist_filling_indi(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//bool current_layer_filling_indi(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
bool current_nodelist_filling_indi(const QList<std::shared_ptr<DAGOrderHelper>>& ordered_nodes);
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 node_adjust_inlayer_forward(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
bool sort_index_partition_indi(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
/**
* .
*
@ -110,6 +112,7 @@ namespace dags {
* \return <²ã´Î£¬ÅÅÐòÖµ>
*/
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);
};
}

3
StoryPresent/dag_present.cpp
View File

@ -314,6 +314,9 @@ void dags::DAGActiveView::refreshGraph()
auto total_nodes = _layout_engine->nodeWithLayout();
total_graph_nodes = this->layer_nodes_construction(QHash<IGraphNode*, std::shared_ptr<DAGOrderHelper>>(), total_nodes);
auto rect = this->scene()->itemsBoundingRect();
this->scene()->setSceneRect(rect);
}
void DAGActiveView::mousePressEvent(QMouseEvent* ev) {

6
StoryPresent/storypresent.cpp
View File

@ -18,9 +18,9 @@ StoryPresent::StoryPresent(QWidget* parent)
view->addAction(u8"放大", this, &StoryPresent::bigger, Qt::CTRL + Qt::Key_P);
auto layout = mbar->addMenu(u8"布局调整");
layout->addAction(u8"ÕýÏò²¼¾Ö", this, &StoryPresent::forwardLayout);
layout->addAction(u8"ÄæÏò²¼¾Ö", this, &StoryPresent::backwardLayout);
layout->addAction(u8"µ÷Õû²¼¾Ö", this, &StoryPresent::adjustLayout);
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);
}
StoryPresent::~StoryPresent()