300 lines
7.9 KiB
C++
300 lines
7.9 KiB
C++
#include "dag_layout.h"
|
||
using namespace dags;
|
||
using namespace graph_data;
|
||
|
||
DAGLayerHelper::DAGLayerHelper(const Node& bind)
|
||
: bind_node(bind) {
|
||
}
|
||
|
||
Node DAGLayerHelper::bindPoint() const {
|
||
return this->bind_node;
|
||
}
|
||
|
||
int& dags::DAGLayerHelper::inputCount() {
|
||
return this->input_count;
|
||
}
|
||
|
||
int dags::DAGLayerHelper::layerValue() const {
|
||
return this->layer_v;
|
||
}
|
||
|
||
void dags::DAGLayerHelper::setLayerValue(int v) {
|
||
this->layer_v = v;
|
||
}
|
||
|
||
void DAGLayerHelper::nextAppend(std::shared_ptr<DAGLayerHelper> inst) {
|
||
if (this->next_points.contains(inst))
|
||
return;
|
||
this->next_points.append(inst);
|
||
inst->input_count++;
|
||
}
|
||
|
||
QList<std::shared_ptr<DAGLayerHelper>> DAGLayerHelper::nextNodes() const {
|
||
return this->next_points;
|
||
}
|
||
|
||
DAGOrderHelper::DAGOrderHelper(std::shared_ptr<DAGLayerHelper> bind) : layer_bind(bind) {
|
||
this->layer_number = bind->layerValue();
|
||
}
|
||
|
||
DAGOrderHelper::DAGOrderHelper(std::shared_ptr<DAGLayerHelper> f, std::shared_ptr<DAGLayerHelper> t)
|
||
: relate_bind(f), towards_to(t) {
|
||
}
|
||
|
||
bool DAGOrderHelper::isFakeNode() const {
|
||
return !this->layer_bind;
|
||
}
|
||
|
||
std::shared_ptr<DAGLayerHelper> dags::DAGOrderHelper::layerNode() const {
|
||
return this->layer_bind;
|
||
}
|
||
|
||
std::shared_ptr<DAGLayerHelper> dags::DAGOrderHelper::relateNode() const {
|
||
return this->relate_bind;
|
||
}
|
||
|
||
std::shared_ptr<DAGLayerHelper> dags::DAGOrderHelper::towardsNode() const {
|
||
return this->towards_to;
|
||
}
|
||
|
||
int dags::DAGOrderHelper::layerNumber() const {
|
||
return this->layer_number;
|
||
}
|
||
|
||
void dags::DAGOrderHelper::setLayerNumber(int v) {
|
||
this->layer_number = v;
|
||
}
|
||
|
||
double dags::DAGOrderHelper::sortNumber() const {
|
||
return this->sort_number;
|
||
}
|
||
|
||
void dags::DAGOrderHelper::setSortNumber(double v) {
|
||
this->sort_number = v;
|
||
}
|
||
|
||
QList<std::shared_ptr<DAGOrderHelper>> DAGOrderHelper::getUpstreamNodes() const {
|
||
return this->__prev_layer_nodes;
|
||
}
|
||
|
||
void DAGOrderHelper::appendUpstreamNode(std::shared_ptr<DAGOrderHelper> inst) {
|
||
this->__prev_layer_nodes.append(inst);
|
||
}
|
||
|
||
void DAGGraph::rebuildFromEdges(const QList<Arrow>& arrow_list) {
|
||
for (auto& arr : arrow_list) {
|
||
auto start = arr.startPoint();
|
||
std::shared_ptr<DAGLayerHelper> start_helper;
|
||
if (this->graph_inst.contains(start.name())) {
|
||
start_helper = this->graph_inst[start.name()];
|
||
}
|
||
else {
|
||
start_helper = std::make_shared<DAGLayerHelper>(start);
|
||
this->graph_inst[start.name()] = start_helper;
|
||
}
|
||
|
||
auto end = arr.endPoint();
|
||
std::shared_ptr< DAGLayerHelper> end_helper;
|
||
if (this->graph_inst.contains(end.name())) {
|
||
end_helper = this->graph_inst[end.name()];
|
||
}
|
||
else {
|
||
end_helper = std::make_shared<DAGLayerHelper>(end);
|
||
this->graph_inst[end.name()] = end_helper;
|
||
}
|
||
|
||
start_helper->nextAppend(end_helper);
|
||
}
|
||
}
|
||
|
||
QList<std::shared_ptr<DAGOrderHelper>> dags::DAGGraph::nodeWithLayout() const {
|
||
return this->node_with_layout;
|
||
}
|
||
|
||
int dags::DAGGraph::maxLayerCount() const {
|
||
return this->max_layer_count;
|
||
}
|
||
|
||
std::shared_ptr<DAGLayerHelper> DAGGraph::spawns_peak(QList<std::shared_ptr<DAGLayerHelper>>& ref_set) {
|
||
for (auto inst : ref_set) {
|
||
if (!inst->inputCount()) {
|
||
for (auto it_nxt : inst->nextNodes()) {
|
||
it_nxt->inputCount()--;
|
||
if (!ref_set.contains(it_nxt))
|
||
ref_set << it_nxt;
|
||
}
|
||
|
||
ref_set.removeAll(inst);
|
||
this->graph_inst.remove(inst->bindPoint().name());
|
||
return inst;
|
||
}
|
||
}
|
||
|
||
for (auto inst : this->graph_inst.values()) {
|
||
if (!inst->inputCount()) {
|
||
if (ref_set.contains(inst))
|
||
ref_set.removeAll(inst);
|
||
|
||
for (auto it_nxt : inst->nextNodes()) {
|
||
it_nxt->inputCount()--;
|
||
if (!ref_set.contains(it_nxt))
|
||
ref_set << it_nxt;
|
||
}
|
||
|
||
this->graph_inst.remove(inst->bindPoint().name());
|
||
return inst;
|
||
}
|
||
}
|
||
|
||
if (this->graph_inst.size()) {
|
||
throw "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD>з<EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD>λ<EFBFBD>·<EFBFBD><EFBFBD>";
|
||
}
|
||
|
||
return std::shared_ptr<DAGLayerHelper>();
|
||
}
|
||
|
||
void DAGGraph::graph_recovery(QList<std::shared_ptr<DAGLayerHelper>> sort_seqs) {
|
||
for (auto it : sort_seqs) {
|
||
it->inputCount() = 0;
|
||
}
|
||
|
||
for (auto it : sort_seqs) {
|
||
for (auto nxt : it->nextNodes()) {
|
||
nxt->inputCount()++;
|
||
}
|
||
}
|
||
|
||
this->graph_inst.clear();
|
||
for (auto it : sort_seqs) {
|
||
this->graph_inst[it->bindPoint().name()] = it;
|
||
}
|
||
}
|
||
|
||
int DAGGraph::node_layering(std::shared_ptr<DAGLayerHelper> inst, int layer_current) {
|
||
auto max_remains = layer_current;
|
||
if (!layer_current || inst->layerValue() < layer_current) {
|
||
inst->setLayerValue(layer_current);
|
||
|
||
for (auto fork : inst->nextNodes()) {
|
||
max_remains = std::max(this->node_layering(fork, inst->layerValue() + 1), max_remains);
|
||
}
|
||
}
|
||
|
||
return max_remains + 1;
|
||
}
|
||
|
||
int DAGGraph::node_layering_adj(std::shared_ptr<DAGLayerHelper> inst) {
|
||
if (inst->inputCount() > 1)
|
||
return inst->layerValue() - 1;
|
||
|
||
if (!inst->nextNodes().size())
|
||
return inst->layerValue() - 1;
|
||
|
||
auto layer_number = INT_MAX;
|
||
for (auto cinst : inst->nextNodes()) {
|
||
layer_number = std::min(layer_number, this->node_layering_adj(cinst));
|
||
}
|
||
|
||
inst->setLayerValue(layer_number);
|
||
return inst->layerValue() - 1;
|
||
}
|
||
|
||
QList<std::shared_ptr<DAGOrderHelper>> DAGGraph::tidy_graph_nodes() {
|
||
QHash<QString, std::shared_ptr<DAGOrderHelper>> nodes_temp;
|
||
for (auto node : this->graph_inst.values()) {
|
||
nodes_temp[node->bindPoint().name()] = std::make_shared<DAGOrderHelper>(node);
|
||
}
|
||
|
||
QList<std::shared_ptr<DAGOrderHelper>> temp_array(nodes_temp.values());
|
||
for (auto node : this->graph_inst.values()) {
|
||
for (auto next : node->nextNodes()) {
|
||
auto node_links = QList<std::shared_ptr<DAGOrderHelper>>{
|
||
nodes_temp[node->bindPoint().name()]
|
||
};
|
||
for (auto layer_index = node->layerValue() + 1; layer_index < next->layerValue(); ++layer_index) {
|
||
node_links.append(std::make_shared<DAGOrderHelper>(node, next));
|
||
node_links.last()->setLayerNumber(layer_index);
|
||
}
|
||
node_links.append(nodes_temp[next->bindPoint().name()]);
|
||
for (auto idx = 1; idx < node_links.size(); ++idx) {
|
||
auto start_point = node_links[idx - 1];
|
||
auto end_point = node_links[idx];
|
||
end_point->appendUpstreamNode(start_point);
|
||
}
|
||
temp_array.append(node_links.mid(1, node_links.size() - 2));
|
||
}
|
||
}
|
||
return temp_array;
|
||
}
|
||
|
||
void DAGGraph::graph_layer_nodes_sort(int layer_index, QList<std::shared_ptr<DAGOrderHelper>> nodes) {
|
||
QList<std::shared_ptr<DAGOrderHelper>> target_nodes_within_layer;
|
||
for (auto n : nodes)
|
||
if (n->layerNumber() == layer_index) {
|
||
target_nodes_within_layer.append(n);
|
||
}
|
||
|
||
if (target_nodes_within_layer.size()) {
|
||
if (!layer_index) {
|
||
for (auto idx = 0; idx < target_nodes_within_layer.size(); ++idx) {
|
||
target_nodes_within_layer[idx]->setSortNumber(idx + 1);
|
||
}
|
||
}
|
||
else if (layer_index > 0) {
|
||
for (auto target_node : target_nodes_within_layer) {
|
||
QList<float> prev_sorts;
|
||
auto upstream_list = target_node->getUpstreamNodes();
|
||
std::transform(upstream_list.begin(), upstream_list.end(),
|
||
std::back_inserter(prev_sorts), [](std::shared_ptr<DAGOrderHelper> inst) {
|
||
return inst->sortNumber();
|
||
});
|
||
|
||
if (prev_sorts.size()) {
|
||
target_node->setSortNumber(std::accumulate(prev_sorts.begin(), prev_sorts.end(), 0) / prev_sorts.size());
|
||
}
|
||
}
|
||
|
||
std::sort(target_nodes_within_layer.begin(), target_nodes_within_layer.end(),
|
||
[](std::shared_ptr<DAGOrderHelper> a, std::shared_ptr<DAGOrderHelper> b) {
|
||
return a->sortNumber() < b->sortNumber();
|
||
});
|
||
|
||
for (auto idx = 0; idx < target_nodes_within_layer.size(); ++idx) {
|
||
auto target_item = target_nodes_within_layer[idx];
|
||
target_item->setSortNumber(idx + 1);
|
||
}
|
||
}
|
||
|
||
this->graph_layer_nodes_sort(layer_index + 1, nodes);
|
||
}
|
||
}
|
||
|
||
void dags::DAGGraph::graphLayout() {
|
||
QList<std::shared_ptr<DAGLayerHelper>> sort_seqs;
|
||
QList<std::shared_ptr<DAGLayerHelper>> refs;
|
||
while (1) {
|
||
auto peaks = this->spawns_peak(refs);
|
||
if (!peaks)
|
||
break;
|
||
|
||
sort_seqs.append(peaks);
|
||
}
|
||
this->graph_recovery(sort_seqs);
|
||
for (auto item : sort_seqs) {
|
||
if (!item->inputCount()) {
|
||
this->max_layer_count = std::max(this->max_layer_count, this->node_layering(item, 0));
|
||
}
|
||
}
|
||
for (auto item : sort_seqs) {
|
||
if (!item->inputCount()) {
|
||
this->node_layering_adj(item);
|
||
}
|
||
}
|
||
|
||
auto tidy_nodes = this->tidy_graph_nodes();
|
||
this->graph_layer_nodes_sort(0, tidy_nodes);
|
||
this->node_with_layout = tidy_nodes;
|
||
}
|
||
|
||
|