CGasConcentrationGridMap2D.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "maps-precomp.h"  // Precomp header
#include <mrpt/maps/CGasConcentrationGridMap2D.h>
#include <mrpt/obs/CObservationGasSensors.h>
#include <mrpt/math/CMatrix.h>
#include <mrpt/math/ops_containers.h>
#include <mrpt/system/CTicTac.h>
#include <mrpt/img/color_maps.h>
#include <mrpt/core/round.h>  // round()
#include <mrpt/io/CFileGZOutputStream.h>
#include <mrpt/io/CFileGZInputStream.h>
#include <mrpt/system/datetime.h>
#include <mrpt/system/filesystem.h>
#include <mrpt/system/os.h>
#include <mrpt/opengl/CArrow.h>
#include <mrpt/opengl/CSetOfObjects.h>
#include <mrpt/serialization/CArchive.h>
 
using namespace mrpt;
using namespace mrpt::maps;
using namespace mrpt::obs;
using namespace mrpt::io;
using namespace mrpt::poses;
using namespace mrpt::img;
using namespace std;
using namespace mrpt::math;
 
//  =========== Begin of Map definition ============
MAP_DEFINITION_REGISTER(
        "CGasConcentrationGridMap2D,gasGrid",
        mrpt::maps::CGasConcentrationGridMap2D)
 
CGasConcentrationGridMap2D::TMapDefinition::TMapDefinition()
        : min_x(-2),
          max_x(2),
          min_y(-2),
          max_y(2),
          resolution(0.10f),
          mapType(CGasConcentrationGridMap2D::mrKernelDM)
{
}
 
void CGasConcentrationGridMap2D::TMapDefinition::
	loadFromConfigFile_map_specific(
                const mrpt::config::CConfigFileBase& source,
                const std::string& sectionNamePrefix)
{
        // [<sectionNamePrefix>+"_creationOpts"]
        const std::string sSectCreation =
                sectionNamePrefix + string("_creationOpts");
        MRPT_LOAD_CONFIG_VAR(min_x, float, source, sSectCreation);
        MRPT_LOAD_CONFIG_VAR(max_x, float, source, sSectCreation);
        MRPT_LOAD_CONFIG_VAR(min_y, float, source, sSectCreation);
        MRPT_LOAD_CONFIG_VAR(max_y, float, source, sSectCreation);
        MRPT_LOAD_CONFIG_VAR(resolution, float, source, sSectCreation);
        mapType = source.read_enum<CGasConcentrationGridMap2D::TMapRepresentation>(
                sSectCreation, "mapType", mapType);
 
        insertionOpts.loadFromConfigFile(
                source, sectionNamePrefix + string("_insertOpts"));
}
 
void CGasConcentrationGridMap2D::TMapDefinition::dumpToTextStream_map_specific(
        std::ostream& out) const
{
        out << mrpt::format(
                "MAP TYPE                                  = %s\n",
                mrpt::typemeta::TEnumType<
                        CGasConcentrationGridMap2D::TMapRepresentation>::value2name(mapType)
                        .c_str());
        LOADABLEOPTS_DUMP_VAR(min_x, float);
        LOADABLEOPTS_DUMP_VAR(max_x, float);
        LOADABLEOPTS_DUMP_VAR(min_y, float);
        LOADABLEOPTS_DUMP_VAR(max_y, float);
        LOADABLEOPTS_DUMP_VAR(resolution, float);
 
        this->insertionOpts.dumpToTextStream(out);
}
 
mrpt::maps::CMetricMap*
        CGasConcentrationGridMap2D::internal_CreateFromMapDefinition(
                const mrpt::maps::TMetricMapInitializer& _def)
{
        const CGasConcentrationGridMap2D::TMapDefinition& def =
                *dynamic_cast<const CGasConcentrationGridMap2D::TMapDefinition*>(&_def);
        CGasConcentrationGridMap2D* obj = new CGasConcentrationGridMap2D(
                def.mapType, def.min_x, def.max_x, def.min_y, def.max_y,
                def.resolution);
        obj->insertionOptions = def.insertionOpts;
        return obj;
}
//  =========== End of Map definition Block =========
 
IMPLEMENTS_SERIALIZABLE(
        CGasConcentrationGridMap2D, CRandomFieldGridMap2D, mrpt::maps)
 
// Short-cut:
#define LUT_TABLE (*(LUT.table))
 
/*---------------------------------------------------------------
                                                Constructor
  ---------------------------------------------------------------*/
CGasConcentrationGridMap2D::CGasConcentrationGridMap2D(
        TMapRepresentation mapType, float x_min, float x_max, float y_min,
        float y_max, float resolution)
        : CRandomFieldGridMap2D(mapType, x_min, x_max, y_min, y_max, resolution),
          insertionOptions()
{
        // Override defaults:
        insertionOptions.GMRF_saturate_min = 0;
        insertionOptions.GMRF_saturate_max = 1;
        insertionOptions.GMRF_lambdaObsLoss = 1.0;
 
        // Set the grid to initial values (and adjust covariance matrices,...)
        //  Also, calling clear() is mandatory to end initialization of our base
        //  class (read note in CRandomFieldGridMap2D::CRandomFieldGridMap2D)
        CMetricMap::clear();
 
        // Create WindGrids with same dimensions that the original map
        windGrid_module.setSize(x_min, x_max, y_min, y_max, resolution);
        windGrid_direction.setSize(x_min, x_max, y_min, y_max, resolution);
 
        // initialize counter for advection simulation
        timeLastSimulated = mrpt::system::now();
}
 
CGasConcentrationGridMap2D::~CGasConcentrationGridMap2D() {}
/*---------------------------------------------------------------
                                                clear
  ---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::internal_clear()
{
        // Just do the generic clear:
        CRandomFieldGridMap2D::internal_clear();
 
        // Anything else special for this derived class?
 
        if (insertionOptions.useWindInformation)
        {
                // Set default values of the wind grid
                windGrid_module.fill(insertionOptions.default_wind_speed);
                windGrid_direction.fill(insertionOptions.default_wind_direction);
 
                /*float S = windGrid_direction.getSizeX() *
windGrid_direction.getSizeY();
 
                for( unsigned int y=windGrid_direction.getSizeY()/2;
y<windGrid_direction.getSizeY(); y++ )
                {
                        for( unsigned int x=0; x<windGrid_direction.getSizeX(); x++ )
                        {
                                double * wind_cell = windGrid_direction.cellByIndex(x,y);
                                *wind_cell =  3*3.141516/2;
}
                }*/
 
                // Generate Look-Up Table of the Gaussian weights due to wind advection.
                if (!build_Gaussian_Wind_Grid())
                {
                        // mrpt::system::pause();
                        THROW_EXCEPTION("Problem with LUT wind table");
                }
        }
}
 
/*---------------------------------------------------------------
                                                insertObservation
  ---------------------------------------------------------------*/
bool CGasConcentrationGridMap2D::internal_insertObservation(
        const CObservation* obs, const CPose3D* robotPose)
{
        MRPT_START
 
        CPose2D robotPose2D;
        CPose3D robotPose3D;
 
        if (robotPose)
        {
                robotPose2D = CPose2D(*robotPose);
                robotPose3D = (*robotPose);
        }
        else
        {
                // Default values are (0,0,0)
        }
 
        if (IS_CLASS(obs, CObservationGasSensors))
        {
                /********************************************************************
                                        OBSERVATION TYPE: CObservationGasSensors
                ********************************************************************/
                const CObservationGasSensors* o =
                        static_cast<const CObservationGasSensors*>(obs);
 
                if (o->sensorLabel.compare(insertionOptions.gasSensorLabel) == 0)
                {
                        float sensorReading;
                        CPose2D sensorPose;
 
                        if (o->sensorLabel.compare("MCEnose") == 0 ||
                                o->sensorLabel.compare("Full_MCEnose") == 0)
                        {
                                ASSERT_(o->m_readings.size() > insertionOptions.enose_id);
                                const CObservationGasSensors::TObservationENose* it =
                                        &o->m_readings[insertionOptions.enose_id];
 
                                // Compute the 3D sensor pose in world coordinates:
                                sensorPose = CPose2D(
                                        CPose3D(robotPose2D) + CPose3D(it->eNosePoseOnTheRobot));
 
                                // Compute the sensor reading value (Volts):
                                if (insertionOptions.gasSensorType == 0x0000)
                                {  // compute the mean
                                        sensorReading = math::mean(it->readingsVoltage);
                                }
                                else
                                {
                                        // Look for the correct sensor type
                                        size_t i;
                                        for (i = 0; i < it->sensorTypes.size(); i++)
                                        {
                                                if (it->sensorTypes.at(i) ==
                                                        int(insertionOptions.gasSensorType))
                                                        break;
                                        }
 
                                        if (i < it->sensorTypes.size())
                                        {
                                                sensorReading = it->readingsVoltage[i];
                                        }
                                        else
                                        {
                                                cout << "Sensor especified not found, compute default "
                                                                "mean value"
                                                         << endl;
                                                sensorReading = math::mean(it->readingsVoltage);
                                        }
                                }
                        }
                        else  //"GDM, RAE_PID, ENOSE_SIMUL
                        {
                                const CObservationGasSensors::TObservationENose* it =
                                        &o->m_readings[0];
                                // Compute the 3D sensor pose in world coordinates:
                                sensorPose = CPose2D(
                                        CPose3D(robotPose2D) + CPose3D(it->eNosePoseOnTheRobot));
                                sensorReading = it->readingsVoltage[0];
                        }
 
                        // Normalization:
                        sensorReading = (sensorReading - insertionOptions.R_min) /
                                                        (insertionOptions.R_max - insertionOptions.R_min);
 
                        // Update the gross estimates of mean/vars for the whole reading
                        // history (see IROS2009 paper):
                        m_average_normreadings_mean =
                                (sensorReading +
                                 m_average_normreadings_count * m_average_normreadings_mean) /
                                (1 + m_average_normreadings_count);
                        m_average_normreadings_var =
                                (square(sensorReading - m_average_normreadings_mean) +
                                 m_average_normreadings_count * m_average_normreadings_var) /
                                (1 + m_average_normreadings_count);
                        m_average_normreadings_count++;
 
                        // Finally, do the actual map update with that value:
                        this->insertIndividualReading(
                                sensorReading,
                                mrpt::math::TPoint2D(sensorPose.x(), sensorPose.y()));
                        return true;  // Done!
                }  // endif correct "gasSensorLabel"
        }  // end if "CObservationGasSensors"
 
        return false;
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                computeObservationLikelihood
  ---------------------------------------------------------------*/
double CGasConcentrationGridMap2D::internal_computeObservationLikelihood(
        const CObservation* obs, const CPose3D& takenFrom)
{
        MRPT_UNUSED_PARAM(obs);
        MRPT_UNUSED_PARAM(takenFrom);
 
        THROW_EXCEPTION("Not implemented yet!");
}
 
uint8_t CGasConcentrationGridMap2D::serializeGetVersion() const { return 5; }
void CGasConcentrationGridMap2D::serializeTo(
        mrpt::serialization::CArchive& out) const
{
        dyngridcommon_writeToStream(out);
 
        // To assure compatibility: The size of each cell:
        uint32_t n = static_cast<uint32_t>(sizeof(TRandomFieldCell));
        out << n;
 
        // Save the map contents:
        n = static_cast<uint32_t>(m_map.size());
        out << n;
 
// Save the "m_map": This requires special handling for big endian systems:
#if MRPT_IS_BIG_ENDIAN
        for (uint32_t i = 0; i < n; i++)
        {
                out << m_map[i].kf_mean << m_map[i].dm_mean << m_map[i].dmv_var_mean;
        }
#else
        // Little endian: just write all at once:
        out.WriteBuffer(
                &m_map[0],
                sizeof(m_map[0]) * m_map.size());  // TODO: Do this endianness safe!!
#endif
 
        // Version 1: Save the insertion options:
        out << uint8_t(m_mapType) << m_cov << m_stackedCov;
 
        out << insertionOptions.sigma << insertionOptions.cutoffRadius
                << insertionOptions.R_min << insertionOptions.R_max
                << insertionOptions.KF_covSigma << insertionOptions.KF_initialCellStd
                << insertionOptions.KF_observationModelNoise
                << insertionOptions.KF_defaultCellMeanValue
                << insertionOptions.KF_W_size;
 
        // New in v3:
        out << m_average_normreadings_mean << m_average_normreadings_var
                << uint64_t(m_average_normreadings_count);
 
        out << genericMapParams;  // v4
}
 
// Aux struct used below (must be at global scope for STL):
struct TOldCellTypeInVersion1
{
        float mean, std;
        float w, wr;
};
 
void CGasConcentrationGridMap2D::serializeFrom(
        mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                {
                        dyngridcommon_readFromStream(in, version < 5);
 
                        // To assure compatibility: The size of each cell:
                        uint32_t n;
                        in >> n;
 
                        if (version < 2)
                        {  // Converter from old versions <=1
                                ASSERT_(
                                        n == static_cast<uint32_t>(sizeof(TOldCellTypeInVersion1)));
                                // Load the map contents in an aux struct:
                                in >> n;
                                vector<TOldCellTypeInVersion1> old_map(n);
                                in.ReadBuffer(&old_map[0], sizeof(old_map[0]) * old_map.size());
 
                                // Convert to newer format:
                                m_map.resize(n);
                                for (size_t k = 0; k < n; k++)
                                {
                                        m_map[k].kf_mean =
                                                (old_map[k].w != 0) ? old_map[k].wr : old_map[k].mean;
                                        m_map[k].kf_std =
                                                (old_map[k].w != 0) ? old_map[k].w : old_map[k].std;
                                }
                        }
                        else
                        {
                                ASSERT_EQUAL_(
                                        n, static_cast<uint32_t>(sizeof(TRandomFieldCell)));
                                // Load the map contents:
                                in >> n;
                                m_map.resize(n);
 
// Read the note in writeToStream()
#if MRPT_IS_BIG_ENDIAN
                                for (uint32_t i = 0; i < n; i++)
                                        in >> m_map[i].kf_mean >> m_map[i].dm_mean >>
                                                m_map[i].dmv_var_mean;
#else
                                // Little endian: just read all at once:
                                in.ReadBuffer(&m_map[0], sizeof(m_map[0]) * m_map.size());
#endif
                        }
 
                        // Version 1: Insertion options:
                        if (version >= 1)
                        {
                                uint8_t i;
                                in >> i;
                                m_mapType = TMapRepresentation(i);
 
                                in >> m_cov >> m_stackedCov;
 
                                in >> insertionOptions.sigma >> insertionOptions.cutoffRadius >>
                                        insertionOptions.R_min >> insertionOptions.R_max >>
                                        insertionOptions.KF_covSigma >>
                                        insertionOptions.KF_initialCellStd >>
                                        insertionOptions.KF_observationModelNoise >>
                                        insertionOptions.KF_defaultCellMeanValue >>
                                        insertionOptions.KF_W_size;
                        }
 
                        if (version >= 3)
                        {
                                uint64_t N;
                                in >> m_average_normreadings_mean >>
                                        m_average_normreadings_var >> N;
                                m_average_normreadings_count = N;
                        }
 
                        if (version >= 4) in >> genericMapParams;
 
                        m_hasToRecoverMeanAndCov = true;
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
/*---------------------------------------------------------------
                                        TInsertionOptions
 ---------------------------------------------------------------*/
CGasConcentrationGridMap2D::TInsertionOptions::TInsertionOptions()
        :
 
          gasSensorLabel("MCEnose"),
          enose_id(0),  // By default use the first enose
          gasSensorType(
                  0x0000),  // By default use the mean between all e-nose sensors
          windSensorLabel("windSensor"),
          useWindInformation(false),  // By default dont use wind
          std_windNoise_phi(0.2f),
          std_windNoise_mod(0.2f),
          default_wind_direction(0.0f),
          default_wind_speed(1.0f)
{
}
 
void CGasConcentrationGridMap2D::TInsertionOptions::dumpToTextStream(
        std::ostream& out) const
{
        out << mrpt::format(
                "\n----------- [CGasConcentrationGridMap2D::TInsertionOptions] "
                "------------ \n\n");
        out << mrpt::format("[TInsertionOptions.Common] ------------ \n\n");
        internal_dumpToTextStream_common(
                out);  // Common params to all random fields maps:
 
        out << mrpt::format("[TInsertionOptions.GasSpecific] ------------ \n\n");
        out << mrpt::format(
                "gasSensorLabel                                                 = %s\n",
                gasSensorLabel.c_str());
        out << mrpt::format(
                "enose_id                                                               = %u\n", (unsigned)enose_id);
        out << mrpt::format(
                "gasSensorType                                                  = %u\n",
                (unsigned)gasSensorType);
        out << mrpt::format(
                "windSensorLabel                                                        = %s\n",
                windSensorLabel.c_str());
        out << mrpt::format(
                "useWindInformation                                             = %u\n", useWindInformation);
 
        out << mrpt::format(
                "advectionFreq                                                  = %f\n", advectionFreq);
        out << mrpt::format(
                "default_wind_direction                                 = %f\n",
                default_wind_direction);
        out << mrpt::format(
                "default_wind_speed                                             = %f\n", default_wind_speed);
        out << mrpt::format(
                "std_windNoise_phi                                              = %f\n", std_windNoise_phi);
        out << mrpt::format(
                "std_windNoise_mod                                              = %f\n", std_windNoise_mod);
 
        out << mrpt::format("\n");
}
 
/*---------------------------------------------------------------
                                        loadFromConfigFile
  ---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::TInsertionOptions::loadFromConfigFile(
        const mrpt::config::CConfigFileBase& iniFile, const std::string& section)
{
        // Common data fields for all random fields maps:
        internal_loadFromConfigFile_common(iniFile, section);
 
        // Specific data fields for gasGridMaps
        gasSensorLabel = iniFile.read_string(
                section.c_str(), "gasSensorLabel", "Full_MCEnose", true);
        enose_id = iniFile.read_int(section.c_str(), "enoseID", enose_id);
        // Read sensor type in hexadecimal
        {
                std::string sensorType_str =
                        iniFile.read_string(section.c_str(), "gasSensorType", "-1", true);
                int tmpSensorType;
                stringstream convert(sensorType_str);
                convert >> std::hex >> tmpSensorType;
 
                if (tmpSensorType >= 0)
                {
                        // Valid number found:
                        gasSensorType = tmpSensorType;
                }
                else
                {  // fall back to old name, or default to current value:
                        gasSensorType = iniFile.read_int(
                                section.c_str(), "KF_sensorType", gasSensorType, true);
                }
        }
        windSensorLabel = iniFile.read_string(
                section.c_str(), "windSensorLabel", "Full_MCEnose", true);
 
        // Indicates if wind information must be used for Advection Simulation
        useWindInformation =
                iniFile.read_bool(section.c_str(), "useWindInformation", "false", true);
 
        //(rad) The initial/default value of the wind direction
        default_wind_direction =
                iniFile.read_float(section.c_str(), "default_wind_direction", 0, false);
        //(m/s) The initial/default value of the wind speed
        default_wind_speed =
                iniFile.read_float(section.c_str(), "default_wind_speed", 0, false);
 
        //(rad) The noise in the wind direction
        std_windNoise_phi =
                iniFile.read_float(section.c_str(), "std_windNoise_phi", 0, false);
        //(m/s) The noise in the wind strenght
        std_windNoise_mod =
                iniFile.read_float(section.c_str(), "std_windNoise_mod", 0, false);
 
        //(m/s) The noise in the wind strenght
        advectionFreq =
                iniFile.read_float(section.c_str(), "advectionFreq", 1, true);
}
 
/*---------------------------------------------------------------
                                                getAs3DObject
---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::getAs3DObject(
        mrpt::opengl::CSetOfObjects::Ptr& outObj) const
{
        MRPT_START
        if (!genericMapParams.enableSaveAs3DObject) return;
        CRandomFieldGridMap2D::getAs3DObject(outObj);
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                getAs3DObject
---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::getAs3DObject(
        mrpt::opengl::CSetOfObjects::Ptr& meanObj,
        mrpt::opengl::CSetOfObjects::Ptr& varObj) const
{
        MRPT_START
        if (!genericMapParams.enableSaveAs3DObject) return;
        CRandomFieldGridMap2D::getAs3DObject(meanObj, varObj);
        MRPT_END
}
 
/*---------------------------------------------------------------
                                                getWindAs3DObject
---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::getWindAs3DObject(
        mrpt::opengl::CSetOfObjects::Ptr& windObj) const
{
        // Return an arrow map of the wind state (module(color) and direction).
        float scale = 0.2f;
        size_t arrow_separation =
                5;  // distance between arrows, expresed as times the cell resolution
 
        // map limits
        float x_min = getXMin();
        float x_max = getXMax();
        float y_min = getYMin();
        float y_max = getYMax();
        float resol = getResolution();
 
        // Ensure map dimensions match with wind map
        unsigned int wind_map_size =
                windGrid_direction.getSizeX() * windGrid_direction.getSizeY();
        ASSERT_(
                wind_map_size ==
                windGrid_module.getSizeX() * windGrid_module.getSizeY());
        if (m_map.size() != wind_map_size)
        {
                cout << " GAS MAP DIMENSIONS DO NOT MATCH WIND MAP " << endl;
                // mrpt::system::pause();
        }
 
        unsigned int cx, cy;
        vector<float> xs, ys;
 
        // xs: array of X-axis values
        xs.resize(floor((x_max - x_min) / (arrow_separation * resol)));
        for (cx = 0; cx < xs.size(); cx++)
                xs[cx] = x_min + arrow_separation * resol * cx;
 
        // ys: array of X-axis values
        ys.resize(floor((y_max - y_min) / (arrow_separation * resol)));
        for (cy = 0; cy < ys.size(); cy++)
                ys[cy] = y_min + arrow_separation * resol * cy;
 
        for (cy = 0; cy < ys.size(); cy++)
        {
                for (cx = 0; cx < xs.size(); cx++)
                {
                        // Cell values [0,inf]:
                        double dir_xy = *windGrid_direction.cellByPos(xs[cx], ys[cy]);
                        double mod_xy = *windGrid_module.cellByPos(xs[cx], ys[cy]);
 
                        auto obj = mrpt::opengl::CArrow::Create(
                                xs[cx], ys[cy], 0.f, xs[cx] + scale * (float)cos(dir_xy),
                                ys[cy] + scale * (float)sin(dir_xy), 0.f, 1.15f * scale,
                                0.3f * scale, 0.35f * scale);
 
                        float r, g, b;
                        jet2rgb(mod_xy, r, g, b);
                        obj->setColor(r, g, b);
 
                        windObj->insert(obj);
                }
        }
}
 
/*---------------------------------------------------------------
                                                increaseUncertainty
---------------------------------------------------------------*/
void CGasConcentrationGridMap2D::increaseUncertainty(
        const double STD_increase_value)
{
        // Increase cell variance
        //      unsigned int cx,cy;
        //      double memory_retention;
 
        m_hasToRecoverMeanAndCov = true;
        for (size_t it = 0; it < m_map.size(); it++)
        {
                m_stackedCov(it, 0) = m_stackedCov(it, 0) + STD_increase_value;
        }
 
        // Update m_map.kf_std
        recoverMeanAndCov();
 
        // for (cy=0; cy<m_size_y; cy++)
        //   {
        //       for (cx=0; cx<m_size_x; cx++)
        //       {
        //              // Forgetting_curve --> memory_retention =
        // exp(-time/memory_relative_strenght)
        //              memory_retention = exp(- mrpt::system::timeDifference(m_map[cx +
        // cy*m_size_x].last_updated, now()) / memory_relative_strenght);
        //              //Update Uncertainty (STD)
        //              m_map[cx + cy*m_size_x].kf_std = 1 - ( (1-m_map[cx +
        // cy*m_size_x].updated_std) * memory_retention );
        //       }
        //   }
}
 
/*---------------------------------------------------------------
                                                simulateAdvection
---------------------------------------------------------------*/
bool CGasConcentrationGridMap2D::simulateAdvection(
        const double& STD_increase_value)
{
        /* 1- Ensure we can use Wind Information
        -------------------------------------------------*/
        if (!insertionOptions.useWindInformation) return false;
 
        // Get time since last simulation
        double At =
                mrpt::system::timeDifference(timeLastSimulated, mrpt::system::now());
        cout << endl << " - At since last simulation = " << At << "seconds" << endl;
        // update time of last updated.
        timeLastSimulated = mrpt::system::now();
 
        /* 3- Build Transition Matrix (SA)
          This Matrix contains the probabilities of each cell
          to "be displaced" to other cells by the wind effect.
        ------------------------------------------------------*/
        mrpt::system::CTicTac tictac;
        size_t i = 0, c = 0;
        int cell_i_cx, cell_i_cy;
        float mu_phi, mu_r, mu_modwind;
        const size_t N = m_map.size();
        mrpt::math::CMatrix A(N, N);
        A.fill(0.0);
        // std::vector<double> row_sum(N,0.0);
        double* row_sum = (double*)calloc(N, sizeof(double));
 
        try
        {
                // Ensure map dimensions match with wind map
                unsigned int wind_map_size =
                        windGrid_direction.getSizeX() * windGrid_direction.getSizeY();
                ASSERT_(
                        wind_map_size ==
                        windGrid_module.getSizeX() * windGrid_module.getSizeY());
                if (N != wind_map_size)
                {
                        cout << " GAS MAP DIMENSIONS DO NOT MATCH WIND INFORMATION "
                                 << endl;
                        // mrpt::system::pause();
                }
 
                tictac.Tic();
 
                // Generate Sparse Matrix of the wind advection SA
                for (i = 0; i < N; i++)
                {
                        // Cell_i indx and coordinates
                        idx2cxcy(i, cell_i_cx, cell_i_cy);
 
                        // Read dirwind value of cell i
                        mu_phi = *windGrid_direction.cellByIndex(
                                cell_i_cx, cell_i_cy);  //[0,2*pi]
                        unsigned int phi_indx = round(mu_phi / LUT.phi_inc);
 
                        // Read modwind value of cell i
                        mu_modwind =
                                *windGrid_module.cellByIndex(cell_i_cx, cell_i_cy);  //[0,inf)
                        mu_r = mu_modwind * At;
                        if (mu_r > LUT.max_r) mu_r = LUT.max_r;
                        unsigned int r_indx = round(mu_r / LUT.r_inc);
 
                        // Evaluate LUT
                        ASSERT_(phi_indx < LUT.phi_count);
                        ASSERT_(r_indx < LUT.r_count);
 
                        // define label
                        vector<TGaussianCell>& cells_to_update =
                                LUT_TABLE[phi_indx][r_indx];
 
                        // Generate Sparse Matrix with the wind weights "SA"
                        for (unsigned int ci = 0; ci < cells_to_update.size(); ci++)
                        {
                                int final_cx = cell_i_cx + cells_to_update[ci].cx;
                                int final_cy = cell_i_cy + cells_to_update[ci].cy;
                                // Check if affected cells is within the map
                                if ((final_cx >= 0) && (final_cx < (int)getSizeX()) &&
                                        (final_cy >= 0) && (final_cy < (int)getSizeY()))
                                {
                                        int final_idx = final_cx + final_cy * getSizeX();
 
                                        // Add Value to SA Matrix
                                        if (cells_to_update[ci].value != 0.0)
                                        {
                                                A(final_idx, i) = cells_to_update[ci].value;
                                                row_sum[final_idx] += cells_to_update[ci].value;
                                        }
                                }
                        }  // end-for ci
                }  // end-for cell i
 
                cout << " - SA matrix computed in " << tictac.Tac() << "s" << endl
                         << endl;
        }
        catch (std::exception& e)
        {
                cout << " #########  EXCEPTION computing Transition Matrix (A) "
                                "##########\n: "
                         << e.what() << endl;
                cout << "on cell i= " << i << "  c=" << c << endl << endl;
                return false;
        }
 
        /* Update Mean + Variance as a Gaussian Mixture
        ------------------------------------------------*/
        try
        {
                tictac.Tic();
                // std::vector<double> new_means(N,0.0);
                double* new_means = (double*)calloc(N, sizeof(double));
                // std::vector<double> new_variances(N,0.0);
                double* new_variances = (double*)calloc(N, sizeof(double));
 
                for (size_t it_i = 0; it_i < N; it_i++)
                {
                        //--------
                        // mean
                        //--------
                        for (size_t it_j = 0; it_j < N; it_j++)
                        {
                                if (m_map[it_j].kf_mean != 0 && A(it_i, it_j) != 0)
                                {
                                        if (row_sum[it_i] >= 1)
                                                new_means[it_i] += (A(it_i, it_j) / row_sum[it_i]) *
                                                                                   m_map[it_j].kf_mean;
                                        else
                                                new_means[it_i] += A(it_i, it_j) * m_map[it_j].kf_mean;
                                }
                        }
 
                        //----------
                        // variance
                        //----------
                        // Consider special case (borders cells)
                        if (row_sum[it_i] < 1)
                                new_variances[it_i] =
                                        (1 - row_sum[it_i]) *
                                        square(insertionOptions.KF_initialCellStd);
 
                        for (size_t it_j = 0; it_j < N; it_j++)
                        {
                                if (A(it_i, it_j) != 0)
                                {
                                        if (row_sum[it_i] >= 1)
                                                new_variances[it_i] +=
                                                        (A(it_i, it_j) / row_sum[it_i]) *
                                                        (m_stackedCov(it_j, 0) +
                                                         square(m_map[it_j].kf_mean - new_means[it_i]));
                                        else
                                                new_variances[it_i] +=
                                                        A(it_i, it_j) *
                                                        (m_stackedCov(it_j, 0) +
                                                         square(m_map[it_j].kf_mean - new_means[it_i]));
                                }
                        }
                }
 
                // Update means and Cov of the Kalman filter state
                for (size_t it_i = 0; it_i < N; it_i++)
                {
                        m_map[it_i].kf_mean = new_means[it_i];  // means
 
                        // Variances
                        // Scale the Current Covariances with the new variances
                        for (size_t it_j = 0; it_j < N; it_j++)
                        {
                                m_stackedCov(it_i, it_j) =
                                        (m_stackedCov(it_i, it_j) / m_stackedCov(it_i, it_i)) *
                                        new_variances[it_i];  // variances
                                m_stackedCov(it_j, it_i) = m_stackedCov(it_i, it_j);
                        }
                }
                m_hasToRecoverMeanAndCov = true;
                recoverMeanAndCov();
 
                cout << " - Mean&Var updated in " << tictac.Tac() << "s" << endl;
 
                // Free Memory
                free(row_sum);
                free(new_means);
                free(new_variances);
        }
        catch (std::exception& e)
        {
                cout << " #########  EXCEPTION Updating Covariances ##########\n: "
                         << e.what() << endl;
                cout << "on row i= " << i << "  column c=" << c << endl << endl;
                return false;
        }
 
        // cout << " Increasing general STD..." << endl;
        increaseUncertainty(STD_increase_value);
 
        return true;
}
 
/*---------------------------------------------------------------
                                                build_Gaussian_Wind_Grid
---------------------------------------------------------------*/
 
bool CGasConcentrationGridMap2D::build_Gaussian_Wind_Grid()
/** Builds a LookUp table with the values of the Gaussian Weights result of the
wind advection
*   for a specific condition.
*
*       The LUT contains the values of the Gaussian Weigths and the references to
the cell indexes to be applied.
*       Since the LUT is independent of the wind direction and angle, it generates
the Gaussian Weights for different configurations
*       of wind angle and module values.
*
*       To increase precission, each cell of the grid is sub-divided in subcells of
smaller size.
 
*       cell_i --> Cell origin (We consider our reference system in the bottom left
corner of cell_i ).
                           Is the cell that contains the gas measurement which will be
propagated by the wind.
                           The wind propagates in the shape of a 2D Gaussian with center in
the target cell (cell_j)
*       cell_j --> Target cell. Is the cell where falls the center of the Gaussian
that models the propagation of the gas comming from cell_i.
*/
 
{
        cout << endl << "---------------------------------" << endl;
        cout << " BUILDING GAUSSIAN WIND WEIGHTS " << endl;
        cout << "---------------------------------" << endl << endl;
 
        //-----------------------------
        //          PARAMS
        //-----------------------------
        LUT.resolution = getResolution();  // resolution of the grid-cells (m)
        LUT.std_phi =
                insertionOptions
                        .std_windNoise_phi;  // Standard Deviation in wind Angle (cte)
        LUT.std_r = insertionOptions.std_windNoise_mod /
                                insertionOptions
                                        .advectionFreq;  // Standard Deviation in wind module (cte)
        std::string filename = format(
                "Gaussian_Wind_Weights_res(%f)_stdPhi(%f)_stdR(%f).gz", LUT.resolution,
                LUT.std_phi, LUT.std_r);
 
        // Fixed Params:
        LUT.phi_inc = M_PIf / 8;  // Increment in the wind Angle. (rad)
        LUT.phi_count =
                round(2 * M_PI / LUT.phi_inc) + 1;  // Number of angles to generate
        LUT.r_inc = 0.1f;  // Increment in the wind Module. (m)
        LUT.max_r = 2;  // maximum distance (m) to simulate
        LUT.r_count =
                round(LUT.max_r / LUT.r_inc) + 1;  // Number of wind modules to simulate
 
        LUT.table = new vector<vector<vector<TGaussianCell>>>(
                LUT.phi_count,
                vector<vector<TGaussianCell>>(LUT.r_count, vector<TGaussianCell>()));
 
        // LUT.table = new
        // vector<vector<vector<vector<vector<TGaussianCell>>>>>(LUT.subcell_count,
        // vector<vector<vector<vector<TGaussianCell>>>>(LUT.subcell_count,
        // vector<vector<vector<TGaussianCell>>>(LUT.phi_count,
        // vector<vector<TGaussianCell>>(LUT.r_count,vector<TGaussianCell>()) ) ) );
 
        //-----------------------------
        //    Check if file exists
        //-----------------------------
 
        cout << "Looking for file: " << filename.c_str() << endl;
 
        if (mrpt::system::fileExists(filename.c_str()))
        {
                // file exists. Load lookUptable from file
                cout << "LookUp table found for this configuration. Loading..." << endl;
                return load_Gaussian_Wind_Grid_From_File();
        }
        else
        {
                // file does not exists. Generate LookUp table.
                cout << "LookUp table NOT found. Generating table..." << endl;
 
                bool debug = true;
                FILE* debug_file;
 
                if (debug)
                {
                        debug_file = fopen("simple_LUT.txt", "w");
                        fprintf(
                                debug_file, " phi_inc = %.4f \n r_inc = %.4f \n", LUT.phi_inc,
                                LUT.r_inc);
                        fprintf(
                                debug_file, " std_phi = %.4f \n std_r = %.4f \n", LUT.std_phi,
                                LUT.std_r);
                        fprintf(debug_file, "[ phi ] [ r ] ---> (cx,cy)=Value\n");
                        fprintf(debug_file, "----------------------------------\n");
                }
 
                // For the different possible angles (phi)
                for (size_t phi_indx = 0; phi_indx < LUT.phi_count; phi_indx++)
                {
                        // mean of the phi value
                        float phi = phi_indx * LUT.phi_inc;
 
                        // For the different and possibe wind modules (r)
                        for (size_t r_indx = 0; r_indx < LUT.r_count; r_indx++)
                        {
                                // mean of the radius value
                                float r = r_indx * LUT.r_inc;
 
                                if (debug)
                                {
                                        fprintf(debug_file, "\n[%.2f] [%.2f] ---> ", phi, r);
                                }
 
                                // Estimates Cell_i_position
                                // unsigned int cell_i_cx = 0;
                                // unsigned int cell_i_cy = 0;
                                float cell_i_x = LUT.resolution / 2.0;
                                float cell_i_y = LUT.resolution / 2.0;
 
                                // Estimate target position according to the mean value of wind.
                                // float x_final = cell_i_x + r*cos(phi);
                                // float y_final = cell_i_y + r*sin(phi);
 
                                // Determine cell_j coordinates respect to origin_cell
                                // int cell_j_cx = static_cast<int>(floor(
                                // (x_final)/LUT.resolution ));
                                // int cell_j_cy = static_cast<int>(floor(
                                // (y_final)/LUT.resolution ));
                                // Center of cell_j
                                // float cell_j_x = (cell_j_cx+0.5f)*LUT.resolution;
                                // float cell_j_y = (cell_j_cy+0.5f)*LUT.resolution;
                                // left bottom corner of cell_j
                                // float cell_j_xmin = cell_j_x - LUT.resolution/2.0;
                                // float cell_j_ymin = cell_j_y - LUT.resolution/2.0;
 
                                /* ---------------------------------------------------------------------------------
                                        Generate bounding-box  (+/- 3std) to determine which cells
                                to update
                                ---------------------------------------------------------------------------------*/
                                std::vector<double> vertex_x, vertex_y;
                                vertex_x.resize(14);
                                vertex_y.resize(14);
                                // Bounding-Box initialization
                                double minBBox_x = 1000;
                                double maxBBox_x = -1000;
                                double minBBox_y = 1000;
                                double maxBBox_y = -1000;
 
                                // Consider special case for high uncertainty in PHI. The shape
                                // of the polygon is a donut.
                                double std_phi_BBox = LUT.std_phi;
                                if (std_phi_BBox > M_PI / 3)
                                {
                                        std_phi_BBox = M_PI / 3;  // To avoid problems generating
                                        // the bounding box. For std>pi/3
                                        // the shape is always a donut.
                                }
 
                                // Calculate bounding box limits
                                size_t indx = 0;
                                int sr = 3;
                                for (int sd = (-3); sd <= (3); sd++)
                                {
                                        vertex_x[indx] =
                                                cell_i_x +
                                                (r + sr * LUT.std_r) * cos(phi + sd * std_phi_BBox);
                                        if (vertex_x[indx] < minBBox_x) minBBox_x = vertex_x[indx];
                                        if (vertex_x[indx] > maxBBox_x) maxBBox_x = vertex_x[indx];
 
                                        vertex_y[indx] =
                                                cell_i_y +
                                                (r + sr * LUT.std_r) * sin(phi + sd * std_phi_BBox);
                                        if (vertex_y[indx] < minBBox_y) minBBox_y = vertex_y[indx];
                                        if (vertex_y[indx] > maxBBox_y) maxBBox_y = vertex_y[indx];
 
                                        indx++;
                                }
                                sr = -3;
                                for (int sd = (3); sd >= (-3); sd--)
                                {
                                        vertex_x[indx] =
                                                cell_i_x +
                                                (r + sr * LUT.std_r) * cos(phi + sd * std_phi_BBox);
                                        if (vertex_x[indx] < minBBox_x) minBBox_x = vertex_x[indx];
                                        if (vertex_x[indx] > maxBBox_x) maxBBox_x = vertex_x[indx];
 
                                        vertex_y[indx] =
                                                cell_i_y +
                                                (r + sr * LUT.std_r) * sin(phi + sd * std_phi_BBox);
                                        if (vertex_y[indx] < minBBox_y) minBBox_y = vertex_y[indx];
                                        if (vertex_y[indx] > maxBBox_y) maxBBox_y = vertex_y[indx];
 
                                        indx++;
                                }
 
                                /* ------------------------------------------------------------------------
                                   Determine range of cells to update according to the
                                Bounding-Box limits.
                                   Origin cell is cx=cy= 0   x[0,res), y[0,res)
                                ---------------------------------------------------------------------------*/
                                int min_cx =
                                        static_cast<int>(floor(minBBox_x / LUT.resolution));
                                int max_cx =
                                        static_cast<int>(floor(maxBBox_x / LUT.resolution));
                                int min_cy =
                                        static_cast<int>(floor(minBBox_y / LUT.resolution));
                                int max_cy =
                                        static_cast<int>(floor(maxBBox_y / LUT.resolution));
 
                                int num_cells_affected =
                                        (max_cx - min_cx + 1) * (max_cy - min_cy + 1);
 
                                if (num_cells_affected == 1)
                                {
                                        // Concentration of cell_i moves to cell_a (cx,cy)
                                        TGaussianCell gauss_info;
                                        gauss_info.cx = min_cx;  // since max_cx == min_cx
                                        gauss_info.cy = min_cy;
                                        gauss_info.value = 1;  // prob = 1
 
                                        // Add cell volume to LookUp Table
                                        LUT_TABLE[phi_indx][r_indx].push_back(gauss_info);
 
                                        if (debug)
                                        {
                                                // Save to file (debug)
                                                fprintf(
                                                        debug_file, "(%d,%d)=%.4f", gauss_info.cx,
                                                        gauss_info.cy, gauss_info.value);
                                        }
                                }
                                else
                                {
                                        // Estimate volume of the Gaussian under each affected cell
 
                                        float subcell_pres = LUT.resolution / 10;
                                        // Determine the number of subcells inside the Bounding-Box
                                        const int BB_x_subcells =
                                                (int)(floor((maxBBox_x - minBBox_x) / subcell_pres) + 1);
                                        const int BB_y_subcells =
                                                (int)(floor((maxBBox_y - minBBox_y) / subcell_pres) + 1);
 
                                        double subcell_pres_x =
                                                (maxBBox_x - minBBox_x) / BB_x_subcells;
                                        double subcell_pres_y =
                                                (maxBBox_y - minBBox_y) / BB_y_subcells;
 
                                        // Save the W value of each cell using a map
                                        std::map<std::pair<int, int>, float> w_values;
                                        std::map<std::pair<int, int>, float>::iterator it;
                                        float sum_w = 0;
 
                                        for (int scy = 0; scy < BB_y_subcells; scy++)
                                        {
                                                for (int scx = 0; scx < BB_x_subcells; scx++)
                                                {
                                                        // P-Subcell coordinates (center of the p-subcell)
                                                        float subcell_a_x =
                                                                minBBox_x + (scx + 0.5f) * subcell_pres_x;
                                                        float subcell_a_y =
                                                                minBBox_y + (scy + 0.5f) * subcell_pres_y;
 
                                                        // distance and angle between cell_i and subcell_a
                                                        float r_ia = sqrt(
                                                                square(subcell_a_x - cell_i_x) +
                                                                square(subcell_a_y - cell_i_y));
                                                        float phi_ia = atan2(
                                                                subcell_a_y - cell_i_y, subcell_a_x - cell_i_x);
 
                                                        // Volume Approximation of subcell_a (Gaussian
                                                        // Bivariate)
                                                        float w =
                                                                (1 / (2 * M_PI * LUT.std_r * LUT.std_phi)) *
                                                                exp(-0.5 *
                                                                        (square(r_ia - r) / square(LUT.std_r) +
                                                                         square(phi_ia - phi) /
                                                                                 square(LUT.std_phi)));
                                                        w += (1 / (2 * M_PI * LUT.std_r * LUT.std_phi)) *
                                                                 exp(-0.5 *
                                                                         (square(r_ia - r) / square(LUT.std_r) +
                                                                          square(phi_ia + 2 * M_PI - phi) /
                                                                                  square(LUT.std_phi)));
                                                        w += (1 / (2 * M_PI * LUT.std_r * LUT.std_phi)) *
                                                                 exp(-0.5 *
                                                                         (square(r_ia - r) / square(LUT.std_r) +
                                                                          square(phi_ia - 2 * M_PI - phi) /
                                                                                  square(LUT.std_phi)));
 
                                                        // Since we work with a cell grid, approximate the
                                                        // weight of the gaussian by the volume of the
                                                        // subcell_a
                                                        if (r_ia != 0.0)
                                                                w =
                                                                        (w * (subcell_pres_x * subcell_pres_y) /
                                                                         r_ia);
 
                                                        // Determine cell index of the current subcell
                                                        int cell_cx = static_cast<int>(
                                                                floor(subcell_a_x / LUT.resolution));
                                                        int cell_cy = static_cast<int>(
                                                                floor(subcell_a_y / LUT.resolution));
 
                                                        // Save w value
                                                        it =
                                                                w_values.find(std::make_pair(cell_cx, cell_cy));
                                                        if (it != w_values.end())  // already exists
                                                                w_values[std::make_pair(cell_cx, cell_cy)] += w;
                                                        else
                                                                w_values[std::make_pair(cell_cx, cell_cy)] = w;
 
                                                        sum_w = sum_w + w;
                                                }  // end-for scx
                                        }  // end-for scy
 
                                        // SAVE to LUT
                                        for (it = w_values.begin(); it != w_values.end(); it++)
                                        {
                                                float w_final =
                                                        (it->second) / sum_w;  // normalization to 1
 
                                                if (w_final >= 0.001)
                                                {
                                                        // Save the weight of the gaussian volume for cell_a
                                                        // (cx,cy)
                                                        TGaussianCell gauss_info;
                                                        gauss_info.cx = it->first.first;
                                                        gauss_info.cy = it->first.second;
                                                        gauss_info.value = w_final;
 
                                                        // Add cell volume to LookUp Table
                                                        LUT_TABLE[phi_indx][r_indx].push_back(gauss_info);
 
                                                        if (debug)
                                                        {
                                                                // Save to file (debug)
                                                                fprintf(
                                                                        debug_file, "(%d,%d)=%.6f    ",
                                                                        gauss_info.cx, gauss_info.cy,
                                                                        gauss_info.value);
                                                        }
                                                }
                                        }
 
                                        // OLD WAY
 
                                        /* ---------------------------------------------------------
                                           Estimate the volume of the Gaussian on each affected cell
                                        //-----------------------------------------------------------*/
                                        // for(int cx=min_cx; cx<=max_cx; cx++)
                                        //{
                                        //      for(int cy=min_cy; cy<=max_cy; cy++)
                                        //      {
                                        //              // Coordinates of affected cell (center of the cell)
                                        //              float cell_a_x = (cx+0.5f)*LUT.resolution;
                                        //              float cell_a_y = (cy+0.5f)*LUT.resolution;
                                        //              float w_cell_a = 0.0;   //initial Gaussian value of
                                        // cell afected
 
                                        //              // Estimate volume of the Gaussian under cell (a)
                                        //              // Partition each cell into (p x p) subcells and
                                        // evaluate the gaussian.
                                        //              int p = 40;
                                        //              float subcell_pres = LUT.resolution/p;
                                        //              float cell_a_x_min = cell_a_x - LUT.resolution/2.0;
                                        //              float cell_a_y_min = cell_a_y - LUT.resolution/2.0;
 
                                        //
                                        //              for(int scy=0; scy<p; scy++)
                                        //              {
                                        //                      for(int scx=0; scx<p; scx++)
                                        //                      {
                                        //                              //P-Subcell coordinates (center of the
                                        // p-subcell)
                                        //                              float subcell_a_x = cell_a_x_min +
                                        //(scx+0.5f)*subcell_pres;
                                        //                              float subcell_a_y = cell_a_y_min +
                                        //(scy+0.5f)*subcell_pres;
 
                                        //                              //distance and angle between cell_i and
                                        // subcell_a
                                        //                              float r_ia = sqrt(
                                        // square(subcell_a_x-cell_i_x)
                                        //+
                                        // square(subcell_a_y-cell_i_y) );
                                        //                              float phi_ia = atan2(subcell_a_y-cell_i_y,
                                        // subcell_a_x-cell_i_x);
 
                                        //                              //Volume Approximation of subcell_a
                                        //(Gaussian
                                        // Bivariate)
                                        //                              float w = (1/(2*M_PI*LUT.std_r*LUT.std_phi))
                                        //*
                                        // exp(-0.5*( square(r_ia-r)/square(LUT.std_r) +
                                        // square(phi_ia-phi)/square(LUT.std_phi) ) );
                                        //                              w += (1/(2*M_PI*LUT.std_r*LUT.std_phi)) *
                                        // exp(-0.5*( square(r_ia-r)/square(LUT.std_r) +
                                        // square(phi_ia+2*M_PI-phi)/square(LUT.std_phi) ) );
                                        //                              w += (1/(2*M_PI*LUT.std_r*LUT.std_phi)) *
                                        // exp(-0.5*( square(r_ia-r)/square(LUT.std_r) +
                                        // square(phi_ia-2*M_PI-phi)/square(LUT.std_phi) ) );
                                        //
                                        //                              //Since we work with a cell grid,
                                        // approximate
                                        // the
                                        // weight of the gaussian by the volume of the subcell_a
                                        //                              if (r_ia != 0.0)
                                        //                                      w_cell_a = w_cell_a + (w *
                                        // square(subcell_pres)/r_ia);
                                        //                      }//end-for scx
                                        //              }//end-for scy
 
                                        //              //Save the weight of the gaussian volume for cell_a
                                        //(cx,cy)
                                        //              TGaussianCell gauss_info;
                                        //              gauss_info.cx = cx;
                                        //              gauss_info.cy = cy;
                                        //              gauss_info.value = w_cell_a;
 
                                        //              //Add cell volume to LookUp Table
                                        //              LUT_TABLE[phi_indx][r_indx].push_back(gauss_info);
 
                                        //              if (debug)
                                        //              {
                                        //                      //Save to file (debug)
                                        //                      fprintf(debug_file, "(%d,%d)=%.6f
                                        //",gauss_info.cx, gauss_info.cy, gauss_info.value);
                                        //              }
                                        //
                                        //
                                        //      }//end-for cy
                                        //}//end-for cx
 
                                }  // end-if only one affected cell
 
                        }  // end-for r
                }  // end-for phi
 
                if (debug) fclose(debug_file);
 
                // Save LUT to File
                return save_Gaussian_Wind_Grid_To_File();
 
        }  // end-if table not available
}
 
bool CGasConcentrationGridMap2D::save_Gaussian_Wind_Grid_To_File()
{
        // Save LUT to file
        cout << "Saving to File ....";
 
        CFileGZOutputStream fo(
                format(
                        "Gaussian_Wind_Weights_res(%f)_stdPhi(%f)_stdR(%f).gz",
                        LUT.resolution, LUT.std_phi, LUT.std_r));
        if (!fo.fileOpenCorrectly())
        {
                return false;
                cout << "WARNING: Gaussian_Wind_Weights file NOT SAVED" << endl;
        }
        auto f = mrpt::serialization::archiveFrom(fo);
 
        try
        {
                // Save params first
                f << LUT.resolution;  // cell resolution used
                f << LUT.std_phi;  // std_phi used
                f << LUT.std_r;
 
                f << LUT.phi_inc;  // rad
                f << (float)LUT.phi_count;
                f << LUT.r_inc;  // m
                f << LUT.max_r;  // maximum distance (m)
                f << (float)LUT.r_count;
 
                // Save Multi-table
                // vector< vector< vector<TGaussianCell>>>>> *table;
 
                for (size_t phi_indx = 0; phi_indx < LUT.phi_count; phi_indx++)
                {
                        for (size_t r_indx = 0; r_indx < LUT.r_count; r_indx++)
                        {
                                // save all cell values.
                                size_t N = LUT_TABLE[phi_indx][r_indx].size();
                                f << (float)N;
 
                                for (size_t i = 0; i < N; i++)
                                {
                                        f << (float)LUT_TABLE[phi_indx][r_indx][i].cx;
                                        f << (float)LUT_TABLE[phi_indx][r_indx][i].cy;
                                        f << LUT_TABLE[phi_indx][r_indx][i].value;
                                }
                        }
                }
                cout << "DONE" << endl;
                return true;
        }
        catch (exception e)
        {
                cout << endl
                         << "------------------------------------------------------------"
                         << endl;
                cout << "EXCEPTION WHILE SAVING LUT TO FILE" << endl;
                cout << "Exception = " << e.what() << endl;
                return false;
        }
}
 
bool CGasConcentrationGridMap2D::load_Gaussian_Wind_Grid_From_File()
{
        // LOAD LUT from file
        cout << "Loading from File ....";
 
        try
        {
                CFileGZInputStream fi(
                        format(
                                "Gaussian_Wind_Weights_res(%f)_stdPhi(%f)_stdR(%f).gz",
                                LUT.resolution, LUT.std_phi, LUT.std_r));
                if (!fi.fileOpenCorrectly())
                {
                        cout << "WARNING WHILE READING FROM: Gaussian_Wind_Weights" << endl;
                        return false;
                }
                auto f = mrpt::serialization::archiveFrom(fi);
 
                float t_float;
                unsigned int t_uint;
                // Ensure params from file are correct with the specified in the ini
                // file
                f >> t_float;
                ASSERT_(LUT.resolution == t_float);
 
                f >> t_float;
                ASSERT_(LUT.std_phi == t_float);
 
                f >> t_float;
                ASSERT_(LUT.std_r == t_float);
 
                f >> t_float;
                ASSERT_(LUT.phi_inc == t_float);
 
                f >> t_float;
                t_uint = (unsigned int)t_float;
                ASSERT_(LUT.phi_count == t_uint);
 
                f >> t_float;
                ASSERT_(LUT.r_inc == t_float);
 
                f >> t_float;
                ASSERT_(LUT.max_r == t_float);
 
                f >> t_float;
                t_uint = (unsigned int)t_float;
                ASSERT_(LUT.r_count == t_uint);
 
                // Load Multi-table
                // vector< vector< vector<TGaussianCell>>>>> *table;
 
                for (size_t phi_indx = 0; phi_indx < LUT.phi_count; phi_indx++)
                {
                        for (size_t r_indx = 0; r_indx < LUT.r_count; r_indx++)
                        {
                                // Number of cells to update
                                size_t N;
                                f >> t_float;
                                N = (size_t)t_float;
 
                                for (size_t i = 0; i < N; i++)
                                {
                                        TGaussianCell gauss_info;
                                        f >> t_float;
                                        gauss_info.cx = (int)t_float;
 
                                        f >> t_float;
                                        gauss_info.cy = (int)t_float;
 
                                        f >> gauss_info.value;
 
                                        // Add cell volume to LookUp Table
                                        LUT_TABLE[phi_indx][r_indx].push_back(gauss_info);
                                }
                        }
                }
                cout << "DONE" << endl;
                return true;
        }
        catch (exception e)
        {
                cout << endl
                         << "------------------------------------------------------------"
                         << endl;
                cout << "EXCEPTION WHILE LOADING LUT FROM FILE" << endl;
                cout << "Exception = " << e.what() << endl;
                return false;
        }
}