ximeaAirborneSystem/Source_Files/configfile.cpp

//
// Created by tangchao on 2022/6/28.
//

#include "Header_Files/configfile.h"

Configfile::Configfile()
{

}

void Configfile::setConfigfilePath(string configfilePath)
{
    m_configfilePath = configfilePath;
}

bool Configfile::isConfigfileExist()
{
    QFileInfo info(QString::fromStdString(m_configfilePath));

    return info.exists();
}

bool Configfile::parseConfigfile()
{
    // Read the file. If there is an error, report it and exit.
    try
    {
        cfg.readFile(m_configfilePath);

        return true;
    }
    catch(const FileIOException &fioex)
    {
        std::cerr << "I/O error while reading file." << std::endl;
        return false;
    }
    catch(const ParseException &pex)
    {
        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
                  << " - " << pex.getError() << std::endl;
        return false;
    }
}

bool Configfile::getSpectralBin(int &spectralBin)
{
    try
    {
        spectralBin = cfg.lookup("spectralBin");

        return true;
    }
    catch(const SettingNotFoundException &nfex)
    {
        cerr << "No 'spectralBin' setting in configuration file." << endl;
        return false;
    }
}

bool Configfile::getspatialBin(int &spatialBin)
{
    try
    {
        spatialBin = cfg.lookup("spatialBin");

        return true;
    }
    catch(const SettingNotFoundException &nfex)
    {
        cerr << "No 'spatialBin' setting in configuration file." << endl;
        return false;
    }
}

bool Configfile::getEffectiveWindow(int &width, int &offsetx, int &height, int &offsety)
{
    const Setting& root = cfg.getRoot();

    try
    {
        int spatialBin;
        int spectralBin;
        getspatialBin(spatialBin);
        getSpectralBin(spectralBin);

        string spatialBinString;
        if(spatialBin == 1)
        {
            spatialBinString = "bin1";
        }
        else
        {
            spatialBinString = "bin2";
        }
        const Setting &spatialArgument = root["effective_window"][spatialBinString]["spatial"];
        if(!(spatialArgument.lookupValue("width", width)
             && spatialArgument.lookupValue("offsetx", offsetx)))
        {
            return false;
        }

        string spectralBinString;
        if(spectralBin == 1)
        {
            spectralBinString = "bin1";
        }
        else
        {
            spectralBinString = "bin2";
        }
        const Setting &spectralArgument = root["effective_window"][spectralBinString]["spectral"];
        if(!(spectralArgument.lookupValue("height", height)
             && spectralArgument.lookupValue("offsety", offsety)))
        {
            return false;
        }
    }
    catch(const SettingNotFoundException &nfex)
    {
        // Ignore.
        return false;
    }

    return true;
}

bool Configfile::getEffectiveWindowRoi(int &width, int &offsetx)
{
    const Setting& root = cfg.getRoot();

    try
    {
        const Setting &effective_window = root["effective_window_roi"];
        int count = effective_window.getLength();

        int spatialBin;
        getspatialBin(spatialBin);

        string spatialBinString;
        if(spatialBin == 1)
        {
            spatialBinString = "spatialBin1";
        }
        else
        {
            spatialBinString = "spatialBin2";
        }

        const Setting &window = effective_window[spatialBinString];
        string name = window.getName();

        if(!(window.lookupValue("width", width)
             && window.lookupValue("offsetx", offsetx)
             ))
        {
            return false;
        }
    }
    catch(const SettingNotFoundException &nfex)
    {
        // Ignore.
        return false;
    }

    return true;
}

bool Configfile::getGainOffset(float &gain, float &offset)
{
    const Setting& root = cfg.getRoot();

    try
    {
        const Setting &gainOffset = root["gainOffset"];
        int count = gainOffset.getLength();

        int spectralBin;
        getSpectralBin(spectralBin);

        string spectralBinString;
        if(spectralBin == 1)
        {
            spectralBinString = "spectralBin1";
        }
        else
        {
            spectralBinString = "spectralBin2";
        }

        const Setting &gainOffsetSetting = gainOffset[spectralBinString];
        string name = gainOffsetSetting.getName();

        if(!(gainOffsetSetting.lookupValue("gain", gain)
             && gainOffsetSetting.lookupValue("offset", offset)))
        {
            return false;
        }
    }
    catch(const SettingNotFoundException &nfex)
    {
        // Ignore.
        return false;
    }

    return true;
}

bool Configfile::getSN(QString &SN)
{
    try
    {
        std::string SN_tem = cfg.lookup("SN");
        SN = QString::fromStdString(SN_tem);

        return true;
    }
    catch(const SettingNotFoundException &nfex)
    {
        cerr << "No 'spectralBin' setting in configuration file." << endl;
        return false;
    }
}

bool Configfile::createConfigFile()
{
    using namespace std;
    using namespace libconfig;

    Config cfg;

    Setting &root = cfg.getRoot();

    // Add some settings to the configuration.
    Setting &SN = root.add("SN", Setting::TypeString) = "0098";
    Setting &spatialBin = root.add("spatialBin", Setting::TypeInt) = 2;
    Setting &SpectralBin = root.add("spectralBin", Setting::TypeInt) = 2;

    Setting &effective_window = root.add("effective_window", Setting::TypeGroup);
    Setting &effective_window_Bin1 = effective_window.add("bin1", Setting::TypeGroup);
    Setting &effective_window_Bin1_spatial = effective_window_Bin1.add("spatial", Setting::TypeGroup);
    Setting &effective_window_Bin1_Spectral = effective_window_Bin1.add("spectral", Setting::TypeGroup);
    Setting &effective_window_Bin2 = effective_window.add("bin2", Setting::TypeGroup);
    Setting &effective_window_Bin2_spatial = effective_window_Bin2.add("spatial", Setting::TypeGroup);
    Setting &effective_window_Bin2_Spectral = effective_window_Bin2.add("spectral", Setting::TypeGroup);

    effective_window_Bin1_spatial.add("width", Setting::TypeInt) = 1368;
    effective_window_Bin1_spatial.add("offsetx", Setting::TypeInt) = 288;
    effective_window_Bin1_Spectral.add("height", Setting::TypeInt) = 300;
    effective_window_Bin1_Spectral.add("offsety", Setting::TypeInt) = 348;

    effective_window_Bin2_spatial.add("width", Setting::TypeInt) = 688;
    effective_window_Bin2_spatial.add("offsetx", Setting::TypeInt) = 144;
    effective_window_Bin2_Spectral.add("height", Setting::TypeInt) = 150;
    effective_window_Bin2_Spectral.add("offsety", Setting::TypeInt) = 174;

    Setting &effective_window_roi = root.add("effective_window_roi", Setting::TypeGroup);
    Setting &effective_window_roi_spatialBin1 = effective_window_roi.add("spatialBin1", Setting::TypeGroup);
    Setting &effective_window_roi_spatialBin2 = effective_window_roi.add("spatialBin2", Setting::TypeGroup);

    effective_window_roi_spatialBin1.add("width", Setting::TypeInt) = 1364;
    effective_window_roi_spatialBin1.add("offsetx", Setting::TypeInt) = 14;
//    effective_window_roi_Bin1.add("height", Setting::TypeInt) = 300;
//    effective_window_roi_Bin1.add("offsety", Setting::TypeInt) = 348;

    effective_window_roi_spatialBin2.add("width", Setting::TypeInt) = 682;
    effective_window_roi_spatialBin2.add("offsetx", Setting::TypeInt) = 15;
//    effective_window_roi_Bin2.add("height", Setting::TypeInt) = 151;
//    effective_window_roi_Bin2.add("offsety", Setting::TypeInt) = 174;

    Setting &gainOffset = root.add("gainOffset", Setting::TypeGroup);
    Setting &gainOffsetSpectralBin1 = gainOffset.add("spectralBin1", Setting::TypeGroup);
    Setting &gainOffsetSpectralBin2 = gainOffset.add("spectralBin2", Setting::TypeGroup);

    gainOffsetSpectralBin1.add("gain", Setting::TypeFloat) = 2.00313433;
    gainOffsetSpectralBin1.add("offset", Setting::TypeFloat) = -300.46283157590585;

    gainOffsetSpectralBin2.add("gain", Setting::TypeFloat) = 4.00626868;
    gainOffsetSpectralBin2.add("offset", Setting::TypeFloat) = -299.46126663407176;


    // Write out the new configuration.
    QString output_file = "/media/nvme/300TC/config/ximea.cfg";
    try
    {
        cfg.writeFile(output_file.toStdString().c_str());
        cerr << "New configuration successfully written to: " << output_file.toStdString().c_str() << endl;

    }
    catch(const FileIOException &fioex)
    {
        cerr << "I/O error while writing configuration file: " << output_file.toStdString().c_str() << endl;
        return true;
    }

    return true;
}

bool Configfile::updateConfigFile()
{
    using namespace std;
    using namespace libconfig;

    static const char *output_file = "updated.cfg";

    Config cfg;

    cfg.setOptions(Config::OptionFsync
                   | Config::OptionSemicolonSeparators
                   | Config::OptionColonAssignmentForGroups
                   | Config::OptionOpenBraceOnSeparateLine);

    // Read the file. If there is an error, report it and exit.
    try
    {
        cfg.readFile("example.cfg");
    }
    catch(const FileIOException &fioex)
    {
        std::cerr << "I/O error while reading file." << std::endl;
        return false;
    }
    catch(const ParseException &pex)
    {
        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
                  << " - " << pex.getError() << std::endl;
        return false;
    }

    // Find the 'movies' setting. Add intermediate settings if they don't yet
    // exist.
    Setting &root = cfg.getRoot();

    if(! root.exists("inventory"))
        root.add("inventory", Setting::TypeGroup);

    Setting &inventory = root["inventory"];

    if(! inventory.exists("movies"))
        inventory.add("movies", Setting::TypeList);

    Setting &movies = inventory["movies"];

    // Create the new movie entry.
    Setting &movie = movies.add(Setting::TypeGroup);

    movie.add("title", Setting::TypeString) = "Buckaroo Banzai";
    movie.add("media", Setting::TypeString) = "DVD";
    movie.add("price", Setting::TypeFloat) = 12.99;
    movie.add("qty", Setting::TypeInt) = 20;

    // Write out the updated configuration.
    try
    {
        cfg.writeFile(output_file);
        cerr << "Updated configuration successfully written to: " << output_file
             << endl;

    }
    catch(const FileIOException &fioex)
    {
        cerr << "I/O error while writing file: " << output_file << endl;
        return false;
    }

    return true;
}