tests/test_settings_manager.cpp - master - klischa/AstraScanner2

tests/test_settings_manager.cpp
313 строк10 KB
k k
feat: performance optimizations, CUDA refactor, markers, and documentation
13 июл 2026, 22:34
13 июл 2026, 22:3488a5c76
#include <gtest/gtest.h>
#include <QCoreApplication>
#include <QSettings>
#include "src/settings/SettingsManager.h"
#include "src/project/ProjectManager.h"

class SettingsManagerTest : public ::testing::Test {
protected:
    void SetUp() override {
        if (!QCoreApplication::instance()) {
            static int argc = 1;
            static char arg0[] = "test_settings_manager";
            static char* argv[] = { arg0 };
            new QCoreApplication(argc, argv);
        }
        
        // Очищаем настройки перед тестом
        QSettings settings("AstraScanner", "AstraScanner");
        settings.clear();
        settings.sync();
    }
    
    void TearDown() override {
        // Очищаем настройки после теста и уничтожаем синглтон
        SettingsManager::reset();
    }
};

// Тест: Singleton pattern
TEST_F(SettingsManagerTest, SingletonPattern)
{
    SettingsManager& instance1 = SettingsManager::instance();
    SettingsManager& instance2 = SettingsManager::instance();
    
    EXPECT_EQ(&instance1, &instance2);
}

// Тест: Основные настройки сканирования
TEST_F(SettingsManagerTest, BasicScanSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    // Scan timeout
    sm.setScanTimeoutSec(600);
    EXPECT_EQ(sm.scanTimeoutSec(), 600);
    
    // Voxel leaf size
    sm.setVoxelLeafSize(0.003);
    EXPECT_DOUBLE_EQ(sm.voxelLeafSize(), 0.003);
    
    // Frame skip
    sm.setFrameSkip(5);
    EXPECT_EQ(sm.frameSkip(), 5);
    
    // Depth range
    sm.setDepthMin(0.2);
    sm.setDepthMax(5.0);
    EXPECT_DOUBLE_EQ(sm.depthMin(), 0.2);
    EXPECT_DOUBLE_EQ(sm.depthMax(), 5.0);
    
    // Color camera
    sm.setColorCameraEnabled(true);
    EXPECT_TRUE(sm.colorCameraEnabled());
    
    sm.setColorCameraEnabled(false);
    EXPECT_FALSE(sm.colorCameraEnabled());
}

// Тест: Настройки фильтров
TEST_F(SettingsManagerTest, FilterSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    // SOR
    sm.setSorMeanK(30);
    sm.setSorStddevMul(1.5);
    EXPECT_EQ(sm.sorMeanK(), 30);
    EXPECT_DOUBLE_EQ(sm.sorStddevMul(), 1.5);
    
    // ROR
    sm.setRorRadius(0.025);
    sm.setRorMinNeighbors(8);
    EXPECT_DOUBLE_EQ(sm.rorRadius(), 0.025);
    EXPECT_EQ(sm.rorMinNeighbors(), 8);
}

// Тест: ICP настройки
TEST_F(SettingsManagerTest, ICPSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    sm.setIcpMaxCorrespondenceDistance(0.1);
    sm.setIcpMaxIterations(100);
    sm.setIcpSkipNonConverged(true);
    sm.setIcpVoxelLeafOut(0.005);
    
    EXPECT_DOUBLE_EQ(sm.icpMaxCorrespondenceDistance(), 0.1);
    EXPECT_EQ(sm.icpMaxIterations(), 100);
    EXPECT_TRUE(sm.icpSkipNonConverged());
    EXPECT_DOUBLE_EQ(sm.icpVoxelLeafOut(), 0.005);
}

// Тест: Poisson настройки
TEST_F(SettingsManagerTest, PoissonSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    sm.setPoissonDepth(10);
    sm.setPoissonPointWeight(5.0);
    sm.setPoissonSamplesPerNode(2.0);
    sm.setPoissonNormalRadius(0.02);
    sm.setPoissonKNearest(30);
    
    EXPECT_EQ(sm.poissonDepth(), 10);
    EXPECT_DOUBLE_EQ(sm.poissonPointWeight(), 5.0);
    EXPECT_DOUBLE_EQ(sm.poissonSamplesPerNode(), 2.0);
    EXPECT_DOUBLE_EQ(sm.poissonNormalRadius(), 0.02);
    EXPECT_EQ(sm.poissonKNearest(), 30);
}

// Тест: Настройки путей
TEST_F(SettingsManagerTest, PathSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    sm.setProjectsDirectory("/tmp/projects");
    sm.setLastExportDirectory("/tmp/export");
    
    EXPECT_EQ(sm.projectsDirectory(), "/tmp/projects");
    EXPECT_EQ(sm.lastExportDirectory(), "/tmp/export");
}

// Тест: Оптический трекинг по маркерам
TEST_F(SettingsManagerTest, MarkerTrackingSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    sm.setMarkerSizeMm(25.0);
    sm.setMarkerInitCount(8);
    
    EXPECT_DOUBLE_EQ(sm.markerSizeMm(), 25.0);
    EXPECT_EQ(sm.markerInitCount(), 8);
    
    sm.setMarkerMinArea(50.0f);
    sm.setMarkerMaxArea(1000.0f);
    sm.setMarkerMinCircularity(0.7f);
    sm.setMarkerMinConvexity(0.8f);
    sm.setMarkerMinInertiaRatio(0.5f);
    
    EXPECT_DOUBLE_EQ(sm.markerMinArea(), 50.0);
    EXPECT_DOUBLE_EQ(sm.markerMaxArea(), 1000.0);
    EXPECT_NEAR(sm.markerMinCircularity(), 0.7, 1e-6);
    EXPECT_NEAR(sm.markerMinConvexity(), 0.8, 1e-6);
    EXPECT_DOUBLE_EQ(sm.markerMinInertiaRatio(), 0.5);
}

// Тест: Режим трекинга
TEST_F(SettingsManagerTest, TrackingModeSettings)
{
    SettingsManager& sm = SettingsManager::instance();
    
    sm.setTrackingMode(TrackingMode::ICP);
    EXPECT_EQ(sm.trackingMode(), TrackingMode::ICP);
    
    sm.setTrackingMode(TrackingMode::MarkerBased);
    EXPECT_EQ(sm.trackingMode(), TrackingMode::MarkerBased);
    
    sm.setTrackingMode(TrackingMode::NeuralBased);
    EXPECT_EQ(sm.trackingMode(), TrackingMode::NeuralBased);
}

// Тест: Пороги ICP confirm для нейросетевого трекинга
TEST_F(SettingsManagerTest, NeuralIcpConfirmSettings)
{
    SettingsManager& sm = SettingsManager::instance();

    sm.setNeuralIcpConfirmEnabled(true);
    sm.setNeuralIcpConfirmMaxCorrespondenceDistance(0.035);
    sm.setNeuralIcpConfirmMaxIterations(25);
    sm.setNeuralIcpConfirmMaxFitness(0.004);
    sm.setNeuralIcpConfirmMaxCorrectionTranslation(0.04);
    sm.setNeuralIcpConfirmMaxCorrectionRotationDeg(8.0);

    EXPECT_TRUE(sm.neuralIcpConfirmEnabled());
    EXPECT_DOUBLE_EQ(sm.neuralIcpConfirmMaxCorrespondenceDistance(), 0.035);
    EXPECT_EQ(sm.neuralIcpConfirmMaxIterations(), 25);
    EXPECT_DOUBLE_EQ(sm.neuralIcpConfirmMaxFitness(), 0.004);
    EXPECT_DOUBLE_EQ(sm.neuralIcpConfirmMaxCorrectionTranslation(), 0.04);
    EXPECT_DOUBLE_EQ(sm.neuralIcpConfirmMaxCorrectionRotationDeg(), 8.0);
}

// Тест: Сигнал settingsChanged
TEST_F(SettingsManagerTest, SettingsChangedSignal)
{
    SettingsManager& sm = SettingsManager::instance();
    
    bool signalReceived = false;
    QString receivedKey;
    
    QObject::connect(&sm, &SettingsManager::settingsChanged, 
        [&signalReceived, &receivedKey](const QString& key) {
            signalReceived = true;
            receivedKey = key;
        });
    
    sm.setScanTimeoutSec(300);
    
    EXPECT_TRUE(signalReceived);
    EXPECT_TRUE(receivedKey.contains("timeout"));
}

// Тест: Значения по умолчанию
TEST_F(SettingsManagerTest, DefaultValues)
{
    SettingsManager& sm = SettingsManager::instance();
    
    // Проверяем, что значения по умолчанию существуют и валидны
    EXPECT_GT(sm.scanTimeoutSec(), 0);
    EXPECT_GT(sm.voxelLeafSize(), 0.0);
    EXPECT_GT(sm.frameSkip(), 0);
    EXPECT_GT(sm.depthMin(), 0.0);
    EXPECT_GT(sm.depthMax(), sm.depthMin());
    EXPECT_TRUE(sm.colorCameraEnabled()); // по умолчанию включено
}


// Тест: дефолт детектора маркеров должен совпадать с возможностями сборки.
TEST_F(SettingsManagerTest, MarkerDetectorDefaultMatchesBuild)
{
    SettingsManager& sm = SettingsManager::instance();
#ifdef ASTRA_ENABLE_CCTAG
    EXPECT_EQ(sm.markerDetectorType(), "CCTag");
#else
    EXPECT_EQ(sm.markerDetectorType(), "Circular");
#endif
}

// Тест: Множественные изменения и синхронизация
TEST_F(SettingsManagerTest, MultipleChangesAndSync)
{
    SettingsManager& sm = SettingsManager::instance();
    
    // Множественные изменения
    sm.setScanTimeoutSec(100);
    sm.setVoxelLeafSize(0.001);
    sm.setFrameSkip(10);
    
    // Синхронизация на диск
    sm.sync();
    
    // Пересоздаем менеджер (симуляция перезапуска)
    QSettings settings("AstraScanner", "AstraScanner");
    settings.sync();
    
    // Проверяем, что значения сохранены (через QSettings напрямую)
    EXPECT_EQ(settings.value("scan/timeoutSec", 0).toInt(), 100);
    EXPECT_DOUBLE_EQ(settings.value("scan/voxelLeafSize", 0.0).toDouble(), 0.001);
    EXPECT_EQ(settings.value("scan/frameSkip", 0).toInt(), 10);
}


// Тест: сеттеры нормализуют недопустимые значения вместо записи мусора.
TEST_F(SettingsManagerTest, SetterValidationClampsInvalidValues)
{
    SettingsManager& sm = SettingsManager::instance();

    sm.setScanTimeoutSec(-10);
    EXPECT_GE(sm.scanTimeoutSec(), 1);

    sm.setDepthMin(100.0);
    EXPECT_LT(sm.depthMin(), sm.depthMax());

    sm.setDepthMax(-1.0);
    EXPECT_GT(sm.depthMax(), sm.depthMin());

    sm.setSorStddevMul(-5.0);
    EXPECT_GE(sm.sorStddevMul(), 0.1);

    sm.setRorRadius(-0.5);
    EXPECT_GE(sm.rorRadius(), 0.001);

    sm.setIcpMaxIterations(-20);
    EXPECT_GE(sm.icpMaxIterations(), 1);

    sm.setPoissonSamplesPerNode(0.0);
    EXPECT_GE(sm.poissonSamplesPerNode(), 0.5);

    sm.setMarkerMinCircularity(5.0f);
    EXPECT_LE(sm.markerMinCircularity(), 1.0f);

    sm.setCctagNumRings(99);
    EXPECT_EQ(sm.cctagNumRings(), 3);

    sm.setNeuralIcpConfirmMaxFitness(-1.0);
    EXPECT_GT(sm.neuralIcpConfirmMaxFitness(), 0.0);
}

// Тест: Отрицательные и граничные значения
TEST_F(SettingsManagerTest, EdgeCases)
{
    SettingsManager& sm = SettingsManager::instance();
    
    // Недопустимые значения должны быть нормализованы
    sm.setVoxelLeafSize(0.0);
    EXPECT_DOUBLE_EQ(sm.voxelLeafSize(), 0.0005);
    
    sm.setFrameSkip(1);
    EXPECT_EQ(sm.frameSkip(), 1);
    
    // Большие значения
    sm.setScanTimeoutSec(3600); // 1 час
    EXPECT_EQ(sm.scanTimeoutSec(), 3600);
}