Визуализация графов

#include <QApplication>
#include <QDesktopWidget>
#include <QWidget>
#include <QPainter>
#include <QTextCodec>
#include <QString>
#include <fstream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <iostream>
 
class grafs
{
public:
    grafs(const char* file)
    {
        std::ifstream in(file);
        int n;
        in >> n;
        v.resize(n);
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                int link;
                in >> link;
                if (link != 0)
                    v[i].push_back(j);
            }
        }
    }
 
    grafs(int n)
    {
        v.resize(n);
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                int link = rand() % 100;
                if (link > 85 && i != j)
                    v[i].push_back(j);
            }
        }
    }
 
    std::vector<std::vector<int> > v;
};
 
class myWidget : public QWidget
{
public:
    myWidget (QWidget *parent = 0) : QWidget(parent),
        //mag("C:/Users/Andrej/graphs/input.txt"),
        mag(10),
        q(mag.v.size())
    {
        setWindowTitle(tr("Визуализация графов"));
    }
 
    void paintEvent(QPaintEvent * = nullptr)
    {
        QPainter p(this);
        coordinates(false);
        p.setRenderHint(QPainter::Antialiasing, true);
        p.setRenderHint(QPainter::TextAntialiasing, true);
        p.setPen(QPen(Qt::black, std::min(size().height(), 
                      size().width()) / 40 / q.size(),
                      Qt::SolidLine, Qt::FlatCap));
        p.setBrush(QBrush(Qt::cyan, Qt::SolidPattern));
        p.setFont(QFont("Times", 14));
 
        radius = std::max((std::min(size().height(), 
                                  size().width()) / (14 + q.size())), 16u);
        for (size_t i = 0; i != mag.v.size(); ++i)
        {
            for (size_t j = 0; j != mag.v[i].size(); ++j)
            {
                std::pair<int, int> a, b;
                a = pruning(q[i].first, q[i].second,
                            q[mag.v[i][j]].first, q[mag.v[i][j]].second, radius);
                b = pruning(q[mag.v[i][j]].first, q[mag.v[i][j]].second,
                        q[i].first, q[i].second, radius);
                p.drawLine(a.first, a.second, b.first, b.second);
            }
        }
 
        for (size_t i = 0; i != q.size(); ++i)
        {
            p.drawEllipse(q[i].first - radius,
                          q[i].second - radius, 2 * radius, 2 * radius);
            QString vertices;
            vertices.setNum(i + 1);
 
            p.drawText(q[i].first - p.font().pointSize() / 4,
                       q[i].second + p.font().pointSize() / 2, vertices);
        }
    }
 
    void coordinates(bool f = true)
    {
        srand(time(nullptr));
        int h = size().height();
        int w = size().width();
        int m = std::min(w, h);
        double pi = acos(-1);
        for (size_t i = 0; i != q.size(); ++i)
        {
            if (f == true)
            {
                q[i].first = w / 2 + (m / exp(1)) * cos(2 * pi * i / q.size());
                q[i].second = h / 2 + (m / exp(1)) * sin(2 * pi * i / q.size());
            }
            else
            {
                q[i].first = rand() % (w / 2) + w / 4;
                q[i].second = rand() % (h / 2) + h / 4;
            }
        }
        laying();
    }
 
    void laying()
    {
        int counter = 0;
        double eps = .5;
        int h = size().height();
        int w = size().width();
        int m = std::min(w, h);
        int Length = m / q.size(), SpringConst = 0.8, ElecConst = 3, Grav = 150;
        std::vector<std::pair<double, double> > fxy(q.size());
        bool qw = true;
        while (qw)
        {
            std::pair<double, double> sum, dxy;
            for (size_t i = 0; i != mag.v.size(); ++i)
            {
                std::pair<double, double> f;
                for (size_t j = 0; j != mag.v[i].size(); ++j)
                {
                    double dist = distance(q[i].first, q[i].second,
                                           q[mag.v[i][j]].first, q[mag.v[i][j]].second);
                    dxy.first = q[i].first - q[mag.v[i][j]].first;
                    dxy.second = q[i].second - q[mag.v[i][j]].second;
                    f.first += SpringConst * (dist - Length) *  dxy.first / dist
                            +  ElecConst / (dist * dist) * dxy.first / dist;
                    f.second += SpringConst * (dist - Length) *  dxy.second / dist
                            +  ElecConst / (dist * dist) * dxy.second / dist;
                }
                for (size_t j = 0; j != mag.v.size(); ++j)
                {
                    if (i == j)
                        continue;
                    double dist = distance(q[i].first, q[i].second,
                                           q[j].first, q[j].second);
 
                    dxy.first = q[i].first - q[j].first;
                    dxy.second = q[i].second - q[j].second;
                    f.first +=  Grav * ElecConst / (dist * dist) * dxy.first / dist;
                    f.second += Grav * ElecConst / (dist * dist) * dxy.second / dist;
                }
                fxy[i] = f;
                sum.first += fabs(fxy[i].first);
                sum.second += fabs(fxy[i].second);
            }
 
 
            for (size_t i = 0; i != q.size(); ++i)
            {
                double dist, kx = 200;
 
                dist = q[i].first;
                dxy.first = q[i].first;
                dxy.second = q[i].second;
                fxy[i].first +=  kx * ElecConst / (dist * dist) * dxy.first / dist;
 
                dist = w - q[i].first;
                dxy.first = w - q[i].first;
                dxy.second = w - q[i].second;
                fxy[i].first +=  kx * ElecConst / (dist * dist) * dxy.first / dist;
 
                dist = q[i].second;
                dxy.first = h - q[i].first;
                dxy.second = h - q[i].second;
                fxy[i].second += kx * ElecConst / (dist * dist) * dxy.second / dist;
 
                dist = h - q[i].second;
                dxy.first = h - q[i].first;
                dxy.second = h - q[i].second;
                fxy[i].second += kx * ElecConst / (dist * dist) * dxy.second / dist;
 
                q[i].first += fxy[i].first /10;
                q[i].second += fxy[i].second /10;
            }
            if (sqrt(sum.first * sum.first + sum.second * sum.second ) < eps)
                break;
 
            if (++counter > 5000)
            {
                qw = false;
                std::cout << "error\n" << std::flush;
                break;
            }
        }
 
        std::cout << qw << "\n" << std::flush;
    }
 
    double distance(int x1, int y1, int x2, int y2)
    {
        return sqrt((x1 - x2) * (x1 - x2) +
                    (y1 - y2) * (y1 - y2));
    }
 
    std::pair<int,int> pruning(int x0, int y0, int x1, int y1, int r)
    {
        double x = x1 - x0;
        double y = y1 - y0;
        double a = atan(y / x);
        x = x0 + r * cos(a);
        y = y0 + r * sin(a);
        if (distance(x, y, x1, y1) > distance(x0, y0, x1, y1))
        {
            x = x0 - r * cos(a);
            y = y0 - r * sin(a);
        }
        return std::make_pair(x, y);
    }
    grafs mag;
    std::vector<std::pair<int, int> > q;
    int radius;
};
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QTextCodec *utfcodec = QTextCodec::codecForName("UTF-8");
    QTextCodec::setCodecForTr(utfcodec);
    QTextCodec::setCodecForCStrings(utfcodec);
    myWidget window;
    int x = std::min(app.desktop()->width(), app.desktop()->height()) / 2;
    window.resize(x, x);
    window.show();
    return app.exec();
}