CGAL::Delaunay_triangulation_2<K> efficiency difference in QT6 environment with respect to Visual Studio 2022 environment

[DarkSun812]

I am running an example code I made in both platforms and I am noticing that in QT 6 it is much slower than when I run it in Visual Studio, I am making a delauny mesh with 25 million points, in Visual Studio 2022 environment it takes about 11 seconds and in Qt it takes 38 seconds.

// interpolation.h
#ifndef INTERPOLATION_H
#define INTERPOLATION_H

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

#include <CGAL/Random.h>
#include <CGAL/squared_distance_2.h>

#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Interpolation_traits_2.h>
#include <CGAL/natural_neighbor_coordinates_2.h>
#include <CGAL/interpolation_functions.h>
#include <CGAL/Triangulation_2.h>

#include <CGAL/point_generators_2.h>
#include <CGAL/algorithm.h>
#include <CGAL/Origin.h>

#include <cassert>

#include <chrono>
#include <iostream>

typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::FT                                         Coord_type;
typedef K::Vector_2                                   Vector;
typedef K::Point_2                                    Point;

typedef CGAL::Delaunay_triangulation_2<K>             Delaunay_triangulation;
typedef CGAL::Interpolation_traits_2<K>               Traits;

typedef std::vector< std::pair<Point, Coord_type> >   Coordinate_vector;
typedef std::map<Point, Coord_type, K::Less_xy_2>     Point_value_map;
typedef std::map<Point, Vector, K::Less_xy_2 >       Point_vector_map;

typedef CGAL::Triangulation_2<K>::Face_handle Face_handle;


class Interpolation
{
public:
    Interpolation();
    void setDelaunyData();
    std::vector<Point> points;
    std::vector<Point> pointsInterpolation;
    Point_value_map valuesInterpolation;
    Delaunay_triangulation T;
};

#endif // INTERPOLATION_H

// interpolation.cpp
#include "interpolation.h"
#include <iostream>
#include <fstream>
#include <string>


void initTime(std::string message, std::chrono::high_resolution_clock::time_point& inicio) {
    std::cout << message << std::endl;
    inicio = std::chrono::high_resolution_clock::now();
};

std::chrono::duration<double> endTime(std::string message, std::chrono::high_resolution_clock::time_point& inicio) {

    std::chrono::duration<double> res = std::chrono::high_resolution_clock::now() - inicio;
    std::cout << message << " " << res.count() << " seconds" << std::endl;
    return res;
};


Interpolation::Interpolation() {}

void Interpolation::setDelaunyData(){
    std::chrono::high_resolution_clock::time_point inicio;
    initTime("setDelaunyData...", inicio);

    int cont = 0;
    double x,y,r;
    std::ifstream file("data.txt");
    if (!file) {
        std::cerr << "error." << std::endl;
        return;
    }
    while (file >> x >> y >> r) { 
        points.push_back(Point(x,y));
        Coord_type value2(r);
        valuesInterpolation.insert(std::make_pair(points[cont], value2));
        cont++;
    }
    std::cout << points.size() << " Size" << std::endl;
    endTime("Finalized Copy Data!", inicio);
    std::cout << "Size points: " << points.size() << std::endl;
    std::cout << "Size Interpolation points: " << pointsInterpolation.size() << std::endl;
    initTime("Delauny Triangulation...", inicio);
    T = Delaunay_triangulation();
    T.insert(points.begin(), points.end());
    endTime("Finalized Delauny Triangulation!", inicio);
};

// main.cpp
#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

// mainwindow.cpp

#include "mainwindow.h"
#include "./ui_mainwindow.h"
#include "interpolation.h"

Interpolation *CGALObject;

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    CGALObject = new Interpolation();
    CGALObject->readBinaries();
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
    delete CGALObject;
}

// mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

These are the files of the example I built in Qt isolated from my project to confirm that it was not an error in my project as such, apparently, the result of time is the same in this project generated from scratch

My question is, why does it take so long in Qt6 and so little in visual studio 2022, in both cases I am using release and not debug, since I am aware that with debug it takes longer.

I wanted to upload the data file but it won't let me since it weighs about 500MB.

[lrineau]

Hi @DarkSun812. Your question is not really about CGAL. What is more, the question is a bit incomplete.

For a given executable, what do you call:

• run "in Visual Studio 2022 environment"?

• run "in Qt6".

• For Visual Studio, I assume that is the "Start without debugging" action in Visual Studio. See that documentation page.

• For "Qt6", I assume that is the Qt6 Qt Creator application.

As far as I know, Qt Creator does not have the possibility to start an executable without debugging. So please tell us more about running something "in Qt6".

When one runs an executable in a debugger, the execution is slower, because the debugger is constantly pausing/resuming the execution of the application, in order to monitor its state. That might explain why the execution was slower "in Qt6" (if my guess that it was indeed in the Qt Creator debugger was right).