使用Barnes-Hut进行图表放置的优化问题

时间：2016-05-04 17:01:42

标签： c++ algorithm graph

我一直试图在我的图表可视化应用中找出Force-Directed graph / Barnes-Hut的问题。到目前为止，我已经检查了八叉树的创建，它看起来正确（树用方框表示，圆圈是我的图形节点）： Quadtree test 我的Quadtree中的字段如下：

class Quadtree
{
    public:
        int level;
        Quadtree* trees[2][2][2];
        glm::vec3 vBoundriesBox[8];
        glm::vec3 center;
        bool leaf;
        float combined_weight = 0;
        std::vector<Element*> objects;
        //Addition methods/fields
    private:
    //Additional methods/fields
    protected:
}

这就是我如何递归地向我的四叉树添加元素：

#define MAX_LEVELS 5

void Quadtree::AddObject(Element* object)
{
    this->objects.push_back(object);
}

void Quadtree::Update()
{
    if(this->objects.size()<=1 || level > MAX_LEVELS)
    {
        for(Element* Element:this->objects)
        {
            Element->parent_group = this;
            this->combined_weight += Element->weight;
        }
        return;
    }

    if(leaf)
    {
        GenerateChildren();
        leaf = false;
    }

    while (!this->objects.empty())
    {
        Element* obj = this->objects.back();
        this->objects.pop_back();
        if(contains(trees[0][0][0],obj))
        {
            trees[0][0][0]->AddObject(obj);
            trees[0][0][0]->combined_weight += obj->weight;
        } else if(contains(trees[0][0][1],obj))
        {
            trees[0][0][1]->AddObject(obj);
            trees[0][0][1]->combined_weight += obj->weight;
        } else if(contains(trees[0][1][0],obj))
        {
            trees[0][1][0]->AddObject(obj);
            trees[0][1][0]->combined_weight += obj->weight;
        } else if(contains(trees[0][1][1],obj))
        {
            trees[0][1][1]->AddObject(obj);
            trees[0][1][1]->combined_weight += obj->weight;
        } else if(contains(trees[1][0][0],obj))
        {
            trees[1][0][0]->AddObject(obj);
            trees[1][0][0]->combined_weight += obj->weight;
        } else if(contains(trees[1][0][1],obj))
        {
            trees[1][0][1]->AddObject(obj);
            trees[1][0][1]->combined_weight += obj->weight;
        } else if(contains(trees[1][1][0],obj))
        {
            trees[1][1][0]->AddObject(obj);
            trees[1][1][0]->combined_weight += obj->weight;
        } else if(contains(trees[1][1][1],obj))
        {
            trees[1][1][1]->AddObject(obj);
            trees[1][1][1]->combined_weight += obj->weight;
        }
    }

    for(int i=0;i<2;i++)
    {
        for(int j=0;j<2;j++)
        {
            for(int k=0;k<2;k++)
            {
                trees[i][j][k]->Update();
            }
        }
    }
}

bool Quadtree::contains(Quadtree* child, Element* object)
{
    if(object->pos[0] >= child->vBoundriesBox[0][0] && object->pos[0] <= child->vBoundriesBox[1][0] &&
       object->pos[1] >= child->vBoundriesBox[4][1] && object->pos[1] <= child->vBoundriesBox[0][1] &&
       object->pos[2] >= child->vBoundriesBox[3][2] && object->pos[2] <= child->vBoundriesBox[0][2])
        return true;
    return false;
}

正如您在图片上看到的节点非常集群。我一直试图找出解决排斥力计算的方法，但它仍然不起作用，结果仍然是这样。

所以我如何计算它：

首先在我的主文件中，我在所有图形节点上运行循环：

for(auto& n_el:graph->node_vector)
{
    tree->CheckNode(&n_el);
}

接下来在我的Qyadtree类中，（tree是这个类对象），我有这个递归方法：

void Quadtree::CheckNode(Node* node)
{
    glm::vec3 diff = this->center - node->pos;

    double distance_sqr = (diff.x * diff.x) + (diff.y*diff.y) + (diff.z*diff.z);
    double width_sqr = (vBoundriesBox[1][0] - vBoundriesBox[0][0]) * (vBoundriesBox[1][0] - vBoundriesBox[0][0]);
    if(width_sqr/distance_sqr < 10.0f || leaf)
    {
        if(leaf)
        {
            for(auto& n: objects)
            {
                n->Repulse(&objects);
            }
        }
        else
        {
            node->RepulseWithGroup(this);
        }
    }
    else
    {
        for(int i=0; i<2; i++)
        {
            for(int j=0; j<2; j++)
            {
                for(int k=0; k<2; k++)
                {
                    trees[i][j][k]->CheckNode(node);
                }
            }
        }
    }
}

最后，我有两种方法计算反冲力，取决于它在组和节点之间或两个节点之间的事实：

double Node::Repulse(std::vector<Node*>* nodes)
{
    double dx;
    double dy;
    double dz;
    double force = 0.0;
    double distance_between;
    double delta_weights;
    double temp;
    for(auto& element_node:*nodes)
    {
        if(this->name == element_node->name)
        {
            continue;
        }
        if(!element_node->use) continue;
        delta_weights = 0.5 + abs(this->weight - element_node->weight);
        dx = this->pos[0] - element_node->pos[0];
        dy = this->pos[1] - element_node->pos[1];
        dz = this->pos[2] - element_node->pos[2];
        distance_between = dx * dx + dy * dy + dz * dz;
        force = 0.19998 * delta_weights/(distance_between * distance_between);
        temp = std::min(1.0, force);
        if(temp<0.0001)
        {
            temp = 0;
        }
        double mx = temp * dx;
        double my = temp * dy;
        double mz = temp * dz;
        this->pos[0] += mx;
        this->pos[1] += my;
        this->pos[2] += mz;
        element_node->pos[0] -= mx;
        element_node->pos[1] -= my;
        element_node->pos[2] -= mz;
    }
}

void Node::RepulseWithGroup(Quadtree* tree)
{
    double dx;
    double dy;
    double dz;
    double force = 0.0;
    double distance_between;
    double delta_weights;
    double temp;

    delta_weights = 0.5 + abs(this->weight - tree->combined_weight);
    dx = this->pos[0] - tree->center.x;
    dy = this->pos[1] - tree->center.y;
    dz = this->pos[2] - tree->center.z;
    distance_between = dx * dx + dy * dy + dz * dz;
    force = 0.19998 * delta_weights/(distance_between * distance_between);
    temp = std::min(1.0, force);
    if(temp<0.0001)
    {
        temp = 0;
    }
    double mx = temp * dx;
    double my = temp * dy;
    double mz = temp * dz;
    this->pos[0] += mx + this->parent_group->repulsion_force.x;
    this->pos[1] += my + this->parent_group->repulsion_force.y;
    this->pos[2] += mz + this->parent_group->repulsion_force.z;
}

如果这个想法：

if(width_sqr/distance_sqr < 10.0f || leaf)
    {
        if(leaf)
        {
            for(auto& n: objects)
            {
                n->Repulse(&objects);
            }
        }
        else
        {
            node->RepulseWithGroup(this);
        }
    }

不清楚是因为我已经发现，一棵树叶中可能实际上有多个元素。如果可能已达到最大级别且仍有元素在一个框中，则可能发生这种情况。然后我还需要计算内部节点内的力。

更令我困扰的是这种方法的速度（并且它表明八叉树不能正常工作）是速度。这是表示节点时间/数量的简单图： Plot 据我所知，最初的力导向图算法具有复杂度O(n^2)，但是对于Barnes-Hut，它应该是O(nlogn)。然而，这个情节甚至还没有接近nlogn。

有人能告诉我我在这做错了什么吗？我已经看了很长时间这段代码，而且我不知道我错过了什么。

修改

基于@Ilmari Karonen回答我已经对MAX_LEVELS 5,20,50,100进行了测试。结果如下。因为它看起来没有任何有意义的差异我说（不幸的是） times

1 个答案:

答案 0 :(得分：3)

就在我的头顶，

#define MAX_LEVELS 5

似乎非常低。您可能只是在八叉树中耗尽了深度，导致算法退化为O（ n ²）直接求和。您可能希望尝试将MAX_LEVELS增加到更高的值（至少比如10或20）并查看是否会提高性能。

我没有测试过你的代码，所以我无法确定这是真正的问题，还是唯一的问题。但这绝对是我先检查的。

仔细看看你的代码，我也看到了其他一些潜在的问题。严格来说，这些可能不会影响性能，但它们可能会影响结果的正确性。

首先，你的center类中有一个Quadtree向量，可能代表了子树中节点的质心，但是当你将节点添加到树中时，你似乎永远不会更新该向量。由于您在计算中使用该向量，因此可能会出现虚假结果。

（事实上，由于您使用center向量的一件事是计算节点和子树之间的距离，因此决定是否深入到子树中，这可能也会搞乱你的表现。）

此外，您似乎在遍历树时直接更新位置，这意味着算法生成的轨迹将取决于遍历节点和树展开的顺序。为了获得更一致和可重复的结果，您可能需要首先在算法的当前迭代期间计算每个节点的位移，将其存储在单独的向量中，然后在节点上运行第二次传递以将位移添加到其位置（并重置它以进行下一次迭代。）

另外，我肯定不会是唯一一个发现你有一个名为Quadtree的类来实现 oc 树烦恼的人，是吗？ :)

相关问题
最新问题