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-05 21:15:07 +08:00
parent 6906c2fe10
commit 72675e0519
3 changed files with 145 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
StoryPresent/dag_layout.cpp
View File

@ -65,7 +65,7 @@ void dags::DAGOrderHelper::setLayerNumber(int v) {
this->layer_number = v; this->layer_number = v;
} }
double dags::DAGOrderHelper::sortNumber() const { QVariant dags::DAGOrderHelper::sortNumber() const {
return this->sort_number; return this->sort_number;
} }
@ -230,35 +230,47 @@ QList<std::shared_ptr<DAGOrderHelper>> DAGGraph::tidy_graph_nodes() {
#include <QDebug> #include <QDebug>
void DAGGraph::graph_layer_nodes_sort_forward(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) { void DAGGraph::graph_layer_nodes_sort_forward(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;
for (auto n : nodes) std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(nodes_within_current_layer),
if (n->layerNumber() == layer_index) { [=](std::shared_ptr<DAGOrderHelper> ins) { return ins->layerNumber() == layer_index; });
nodes_within_current_layer.append(n);
}
if (nodes_within_current_layer.size()) { if (nodes_within_current_layer.size()) {
// 计算当前层次所有节点排序 // 计算当前层次所有节点排序
if (!layer_index) { if (!layer_index) {
for (auto idx = 0; idx < nodes_within_current_layer.size(); ++idx) { for (auto idx = 0; idx < nodes_within_current_layer.size(); ++idx) {
nodes_within_current_layer[idx]->setSortNumber(idx + 1); auto target_node = nodes_within_current_layer[idx];
if(target_node->sortNumber().isNull())
target_node->setSortNumber(idx + 1);
} }
} }
else if (layer_index > 0) { else if (layer_index > 0) {
QList<std::shared_ptr<DAGOrderHelper>> nodes_fixed;
for (auto target_node : nodes_within_current_layer) { for (auto target_node : nodes_within_current_layer) {
QList<double> prev_sorts;
auto upstream_list = target_node->getUpstreamNodes(); auto upstream_list = target_node->getUpstreamNodes();
std::transform(upstream_list.begin(), upstream_list.end(), std::sort(upstream_list.begin(), upstream_list.end(),
std::back_inserter(prev_sorts), [](std::shared_ptr<DAGOrderHelper> inst) { [](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) { return a->sortNumber() < b->sortNumber(); });
return inst->sortNumber();
});
if (prev_sorts.size()) { if (upstream_list.size()) {
auto target_sum = std::accumulate(prev_sorts.begin(), prev_sorts.end(), 0.0); auto sort_anchor = upstream_list[(upstream_list.size() - 1) / 2];
target_node->setSortNumber(target_sum / prev_sorts.size()); target_node->setSortNumber(sort_anchor->sortNumber().toInt());
nodes_fixed << sort_anchor;
}
}
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) {
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(); });
for (int idx = 0; idx < nodes_hangout.size(); ++idx) {
nodes_hangout[idx]->setSortNumber((*min_anchor)->sortNumber().toInt() - idx - 1);
} }
} }
// 提取当前层次节点排序值 // 提取当前层次节点排序值
//this->current_nodelist_separate(nodes_within_current_layer);
this->current_nodelist_filling(layer_index, nodes); this->current_nodelist_filling(layer_index, nodes);
} }
@ -268,19 +280,108 @@ void DAGGraph::graph_layer_nodes_sort_forward(int layer_index, const QList<std::
} }
void dags::DAGGraph::current_nodelist_filling(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes) void dags::DAGGraph::current_nodelist_filling(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; });
if(!nodes_within_current_layer.size())
return;
std::sort(nodes_within_current_layer.begin(), nodes_within_current_layer.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();
});
// 提取节点划分档次
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) {
return ins->sortNumber().toInt();
});
ordered_values = ordered_values.toSet().toList();
std::sort(ordered_values.begin(), ordered_values.end());
// 填缝
ordered_values << ordered_values.last() + 1;
for (auto idx = 1; idx < ordered_values.size(); ++idx) {
auto prev_sortv = ordered_values[idx - 1];
auto curr_sortv = ordered_values[idx];
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; });
for (int idx = 0; idx < std::min(curr_sortv - prev_sortv, pick_ups.size()); idx++) {
auto target_node = pick_ups[idx];
target_node->setSortNumber(prev_sortv + idx);
}
if (curr_sortv - prev_sortv < pick_ups.size()) {
auto npicks = pick_ups.mid(curr_sortv - prev_sortv);
auto inc_span = 1.0 / (npicks.size() + 4);
for (auto idx = 0; idx < npicks.size(); ++idx) {
auto nsortv = curr_sortv - 1 + (idx + 1) * inc_span;
npicks[idx]->setSortNumber(nsortv);
}
}
}
}
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; });
// 排序值提取与重排
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(); });
sort_values = sort_values.toSet().toList();
std::sort(sort_values.begin(), sort_values.end());
// 检索排序中轴
auto temp_anchor = std::make_pair<double, int>(DBL_MAX, -1);
for (int nidx = 0; nidx < sort_values.size(); ++nidx) {
auto value_span = std::abs(sort_values[nidx]);
if (value_span <= temp_anchor.first)
temp_anchor = std::make_pair(value_span, nidx);
}
// 排序值重整
for (int sorting_idx = 0; sorting_idx < sorting_nodes.size(); ++sorting_idx) {
auto node = sorting_nodes[sorting_idx];
auto node_sortv = node->sortNumber().toDouble();
auto sort_idx = sort_values.indexOf(node_sortv);
node->setSortNumber(sort_idx - temp_anchor.second);
}
}
/*
void dags::DAGGraph::current_nodelist_filling_backward(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes)
{ {
// 提取既有排序成果 // 提取既有排序成果
QList<std::shared_ptr<DAGOrderHelper>> ordered_node; QList<std::shared_ptr<DAGOrderHelper>> ordered_node;
std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(ordered_node), std::copy_if(nodes.begin(), nodes.end(), std::back_inserter(ordered_node),
[=](std::shared_ptr<DAGOrderHelper> ins) { [=](std::shared_ptr<DAGOrderHelper> ins) {
if (!ins->isFakeNode() && ins->layerNumber() < layer_index) { return !ins->isFakeNode() && ins->layerNumber() > layer_index;
auto next_nodes = ins->layerNode()->nextNodes();
for (auto nd : next_nodes) {
if (nd->layerValue() >= layer_index)
return true;
}
}
return false;
}); });
QList<int> ordered_values; QList<int> ordered_values;
std::transform(ordered_node.begin(), ordered_node.end(), std::back_inserter(ordered_values), std::transform(ordered_node.begin(), ordered_node.end(), std::back_inserter(ordered_values),
@ -327,36 +428,6 @@ void dags::DAGGraph::current_nodelist_filling(int layer_index, const QList<std::
} }
} }
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; });
// 排序值提取与重排
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(); });
sort_values = sort_values.toSet().toList();
std::sort(sort_values.begin(), sort_values.end());
// 检索排序中轴
auto temp_anchor = std::make_pair<double, int>(DBL_MAX, -1);
for (int nidx = 0; nidx < sort_values.size(); ++nidx) {
auto value_span = std::abs(sort_values[nidx]);
if (value_span <= temp_anchor.first)
temp_anchor = std::make_pair(value_span, nidx);
}
// 排序值重整
for (int sorting_idx = 0; sorting_idx < sorting_nodes.size(); ++sorting_idx) {
auto node = sorting_nodes[sorting_idx];
auto sort_idx = sort_values.indexOf(node->sortNumber());
node->setSortNumber(sort_idx - temp_anchor.second);
}
}
void dags::DAGGraph::current_nodelist_separate(const QList<std::shared_ptr<DAGOrderHelper>>& nodes_within_current_layer) void dags::DAGGraph::current_nodelist_separate(const QList<std::shared_ptr<DAGOrderHelper>>& nodes_within_current_layer)
{ {
QList<double> sort_values; QList<double> sort_values;
@ -406,13 +477,13 @@ void dags::DAGGraph::current_layer_separate(int layer_index, const QList<std::sh
this->current_nodelist_separate(nodes_within_current_layer); this->current_nodelist_separate(nodes_within_current_layer);
} }
*/
void dags::DAGGraph::graph_adjust_after_layout(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes) void dags::DAGGraph::graph_adjust_after_layout(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) {
this->layer_adjust_via_next_sibling(layer_index, total_nodes); this->layer_adjust_via_next_sibling(layer_index, total_nodes);
this->current_layer_separate(layer_index, total_nodes); this->current_nodelist_filling(layer_index, total_nodes);
this->nodes_sort_with_belows(layer_index, total_nodes); this->nodes_sort_with_belows(layer_index, total_nodes);
layer_index--; layer_index--;
}; };
@ -540,7 +611,7 @@ void dags::DAGGraph::node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper
}); });
if (next_layer_nodes.size()) { if (next_layer_nodes.size()) {
curr_node->setSortNumber(next_layer_nodes.first()->sortNumber()); curr_node->setSortNumber(next_layer_nodes.first()->sortNumber().toDouble());
} }
} }
@ -554,7 +625,7 @@ void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList<std::sha
// 排序值提取与重排 // 排序值提取与重排
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(); }); [](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());
@ -569,7 +640,7 @@ void dags::DAGGraph::nodes_sort_with_belows(int curr_layer, const QList<std::sha
// 排序值重整 // 排序值重整
for (int sorting_idx = 0; sorting_idx < sorting_nodes.size(); ++sorting_idx) { for (int sorting_idx = 0; sorting_idx < sorting_nodes.size(); ++sorting_idx) {
auto node = sorting_nodes[sorting_idx]; auto node = sorting_nodes[sorting_idx];
auto sort_idx = sort_values.indexOf(node->sortNumber()); auto sort_idx = sort_values.indexOf(node->sortNumber().toDouble());
node->setSortNumber(sort_idx - temp_anchor.second); node->setSortNumber(sort_idx - temp_anchor.second);
} }
} }
@ -601,7 +672,11 @@ void dags::DAGGraph::graphLayout() {
this->graph_layer_nodes_sort_forward(0, tidy_nodes); this->graph_layer_nodes_sort_forward(0, tidy_nodes);
this->node_with_layout = tidy_nodes; this->node_with_layout = tidy_nodes;
this->graph_adjust_after_layout(tidy_nodes); int times = 2;
while(times--){
this->graph_adjust_after_layout(tidy_nodes);
this->graph_layer_nodes_sort_forward(0, tidy_nodes);
}
} }

15
StoryPresent/dag_layout.h
View File

@ -35,7 +35,7 @@ namespace dags {
std::shared_ptr<DAGLayerHelper> relate_bind = nullptr; std::shared_ptr<DAGLayerHelper> relate_bind = nullptr;
std::shared_ptr<DAGLayerHelper> towards_to = nullptr; std::shared_ptr<DAGLayerHelper> towards_to = nullptr;
int layer_number = 0; int layer_number = 0;
double sort_number = 0; QVariant sort_number;
QList<std::shared_ptr<DAGOrderHelper>> __prev_layer_nodes; QList<std::shared_ptr<DAGOrderHelper>> __prev_layer_nodes;
public: public:
@ -60,7 +60,7 @@ namespace dags {
int layerNumber() const; int layerNumber() const;
void setLayerNumber(int v); void setLayerNumber(int v);
double sortNumber() const; QVariant sortNumber() const;
void setSortNumber(double v); void setSortNumber(double v);
QList<std::shared_ptr<DAGOrderHelper>> getUpstreamNodes() const; QList<std::shared_ptr<DAGOrderHelper>> getUpstreamNodes() const;
@ -77,6 +77,7 @@ namespace dags {
public: public:
void rebuildFromEdges(const QList<graph_data::Arrow>& arrow_list); void rebuildFromEdges(const QList<graph_data::Arrow>& arrow_list);
void graphLayout(); void graphLayout();
QList<std::shared_ptr<DAGOrderHelper>> nodeWithLayout() const; QList<std::shared_ptr<DAGOrderHelper>> nodeWithLayout() const;
int maxLayerCount() const; int maxLayerCount() const;
@ -88,11 +89,10 @@ namespace dags {
QList<std::shared_ptr<DAGOrderHelper>> tidy_graph_nodes(); QList<std::shared_ptr<DAGOrderHelper>> tidy_graph_nodes();
void graph_layer_nodes_sort_forward(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>> &nodes); void graph_layer_nodes_sort_forward(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>> &nodes);
void current_nodelist_filling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void nodes_sort_with_above(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void current_nodelist_separate(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes); //void current_nodelist_filling_backward(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
void current_layer_separate(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes); //void current_nodelist_separate(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//void current_layer_separate(int layer_index, const QList<std::shared_ptr<DAGOrderHelper>>& nodes);
void graph_adjust_after_layout(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes); void graph_adjust_after_layout(const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
//bool layer_adjust_after_layout(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes); //bool layer_adjust_after_layout(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
@ -100,6 +100,9 @@ namespace dags {
bool layer_adjust_via_next_sibling(int curr_layer, 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);
void node_adjust_via_next_sibling(std::shared_ptr<DAGOrderHelper> curr_node, 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);
void current_nodelist_filling(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_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 nodes_sort_with_belows(int curr_layer, const QList<std::shared_ptr<DAGOrderHelper>>& total_nodes);
}; };
} }

4
StoryPresent/dag_present.cpp
View File

@ -177,7 +177,7 @@ QList<IGraphNode*> DAGActiveView::layer_nodes_construction(const QHash<IGraphNod
auto to = data_node->headsNode()->bindPoint().name(); auto to = data_node->headsNode()->bindPoint().name();
auto curr_gnode = new PenetrateNode(20, from, to); auto curr_gnode = new PenetrateNode(20, from, to);
this->scene_bind.addItem(curr_gnode); this->scene_bind.addItem(curr_gnode);
curr_gnode->setPos(prev_layer_end, data_node->sortNumber() * (this->node_span + this->font().pointSizeF()) * 7); curr_gnode->setPos(prev_layer_end, data_node->sortNumber().toDouble() * (this->node_span + this->font().pointSizeF()) * 7);
current_nodes_helper[curr_gnode] = data_node; current_nodes_helper[curr_gnode] = data_node;
} }
@ -188,7 +188,7 @@ QList<IGraphNode*> DAGActiveView::layer_nodes_construction(const QHash<IGraphNod
} }
auto curr_gnode = new ActivePresentNode(data_node->layerNode()->bindPoint().name(), node_type_vx, this->font()); auto curr_gnode = new ActivePresentNode(data_node->layerNode()->bindPoint().name(), node_type_vx, this->font());
this->scene_bind.addItem(curr_gnode); this->scene_bind.addItem(curr_gnode);
curr_gnode->setPos(prev_layer_end, data_node->sortNumber() * (this->node_span + this->font().pointSizeF()) * 7); curr_gnode->setPos(prev_layer_end, data_node->sortNumber().toDouble() * (this->node_span + this->font().pointSizeF()) * 7);
current_nodes_helper[curr_gnode] = data_node; current_nodes_helper[curr_gnode] = data_node;
} }