DBDriver.cpp

Go to the documentation of this file.

/*
Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the Universite de Sherbrooke nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
#include "rtabmap/core/DBDriver.h"
 
#include "rtabmap/core/Signature.h"
#include "rtabmap/core/VisualWord.h"
#include "rtabmap/core/DBDriverSqlite3.h"
#include "rtabmap/utilite/UConversion.h"
#include "rtabmap/utilite/UMath.h"
#include "rtabmap/utilite/ULogger.h"
#include "rtabmap/utilite/UTimer.h"
#include "rtabmap/utilite/UStl.h"
 
namespace rtabmap {
 
DBDriver * DBDriver::create(const ParametersMap & parameters)
{
        return new DBDriverSqlite3(parameters);
}
 
DBDriver::DBDriver(const ParametersMap & parameters) :
        _emptyTrashesTime(0),
        _timestampUpdate(true)
{
        this->parseParameters(parameters);
}
 
DBDriver::~DBDriver()
{
        join(true);
        this->emptyTrashes();
}
 
void DBDriver::parseParameters(const ParametersMap & parameters)
{
        Parameters::parse(parameters, Parameters::kDbTargetVersion(), _targetVersion);
}
 
void DBDriver::closeConnection(bool save, const std::string & outputUrl)
{
        UDEBUG("isRunning=%d", this->isRunning());
        this->join(true);
        UDEBUG("");
        if(save)
        {
                this->emptyTrashes();
        }
        else
        {
                _trashesMutex.lock();
                _trashSignatures.clear();
                _trashVisualWords.clear();
                _trashesMutex.unlock();
        }
        _dbSafeAccessMutex.lock();
        this->disconnectDatabaseQuery(save, outputUrl);
        _dbSafeAccessMutex.unlock();
        UDEBUG("");
}
 
bool DBDriver::openConnection(const std::string & url, bool overwritten)
{
        UDEBUG("");
        _url = url;
        _dbSafeAccessMutex.lock();
        if(this->connectDatabaseQuery(url, overwritten))
        {
                _dbSafeAccessMutex.unlock();
                return true;
        }
        _dbSafeAccessMutex.unlock();
        return false;
}
 
bool DBDriver::isConnected() const
{
        bool r;
        _dbSafeAccessMutex.lock();
        r = isConnectedQuery();
        _dbSafeAccessMutex.unlock();
        return r;
}
 
// In bytes
unsigned long DBDriver::getMemoryUsed() const
{
        unsigned long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
 
long DBDriver::getNodesMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getNodesMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getLinksMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getLinksMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getImagesMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getImagesMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getDepthImagesMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getDepthImagesMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getCalibrationsMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getCalibrationsMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getGridsMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getGridsMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getLaserScansMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getLaserScansMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getUserDataMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getUserDataMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getWordsMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getWordsMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getFeaturesMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getFeaturesMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
long DBDriver::getStatisticsMemoryUsed() const
{
        long bytes;
        _dbSafeAccessMutex.lock();
        bytes = getStatisticsMemoryUsedQuery();
        _dbSafeAccessMutex.unlock();
        return bytes;
}
int DBDriver::getLastNodesSize() const
{
        int nodes;
        _dbSafeAccessMutex.lock();
        nodes = getLastNodesSizeQuery();
        _dbSafeAccessMutex.unlock();
        return nodes;
}
int DBDriver::getLastDictionarySize() const
{
        int words;
        _dbSafeAccessMutex.lock();
        words = getLastDictionarySizeQuery();
        _dbSafeAccessMutex.unlock();
        return words;
}
int DBDriver::getTotalNodesSize() const
{
        int words;
        _dbSafeAccessMutex.lock();
        words = getTotalNodesSizeQuery();
        _dbSafeAccessMutex.unlock();
        return words;
}
int DBDriver::getTotalDictionarySize() const
{
        int words;
        _dbSafeAccessMutex.lock();
        words = getTotalDictionarySizeQuery();
        _dbSafeAccessMutex.unlock();
        return words;
}
ParametersMap DBDriver::getLastParameters() const
{
        ParametersMap parameters;
        _dbSafeAccessMutex.lock();
        parameters = getLastParametersQuery();
        _dbSafeAccessMutex.unlock();
        return parameters;
}
 
std::map<std::string, float> DBDriver::getStatistics(int nodeId, double & stamp, std::vector<int> * wmState) const
{
        std::map<std::string, float> statistics;
        _dbSafeAccessMutex.lock();
        statistics = getStatisticsQuery(nodeId, stamp, wmState);
        _dbSafeAccessMutex.unlock();
        return statistics;
}
 
std::map<int, std::pair<std::map<std::string, float>, double> > DBDriver::getAllStatistics() const
{
        std::map<int, std::pair<std::map<std::string, float>, double> > statistics;
        _dbSafeAccessMutex.lock();
        statistics = getAllStatisticsQuery();
        _dbSafeAccessMutex.unlock();
        return statistics;
}
 
std::map<int, std::vector<int> > DBDriver::getAllStatisticsWmStates() const
{
        std::map<int, std::vector<int> > wmStates;
        _dbSafeAccessMutex.lock();
        wmStates = getAllStatisticsWmStatesQuery();
        _dbSafeAccessMutex.unlock();
        return wmStates;
}
 
std::string DBDriver::getDatabaseVersion() const
{
        std::string version = "0.0.0";
        _dbSafeAccessMutex.lock();
        getDatabaseVersionQuery(version);
        _dbSafeAccessMutex.unlock();
        return version;
}
 
void DBDriver::mainLoop()
{
        this->emptyTrashes();
        this->kill(); // Do it only once
}
 
void DBDriver::beginTransaction() const
{
        _transactionMutex.lock();
        ULOGGER_DEBUG("");
        this->executeNoResultQuery("BEGIN TRANSACTION;");
}
 
void DBDriver::commit() const
{
        ULOGGER_DEBUG("");
        this->executeNoResultQuery("COMMIT;");
        _transactionMutex.unlock();
}
 
void DBDriver::executeNoResult(const std::string & sql) const
{
        _dbSafeAccessMutex.lock();
        this->executeNoResultQuery(sql);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::emptyTrashes(bool async)
{
        if(async)
        {
                ULOGGER_DEBUG("Async emptying, start the trash thread");
                this->start();
                return;
        }
 
        UTimer totalTime;
        totalTime.start();
 
        std::map<int, Signature*> signatures;
        std::map<int, VisualWord*> visualWords;
        _trashesMutex.lock();
        {
                ULOGGER_DEBUG("signatures=%d, visualWords=%d", _trashSignatures.size(), _trashVisualWords.size());
                signatures = _trashSignatures;
                visualWords = _trashVisualWords;
                _trashSignatures.clear();
                _trashVisualWords.clear();
 
                _dbSafeAccessMutex.lock();
        }
        _trashesMutex.unlock();
 
        if(signatures.size() || visualWords.size())
        {
                this->beginTransaction();
                UTimer timer;
                timer.start();
                if(signatures.size())
                {
                        if(this->isConnected())
                        {
                                //Only one query to the database
                                this->saveOrUpdate(uValues(signatures));
                        }
 
                        for(std::map<int, Signature *>::iterator iter=signatures.begin(); iter!=signatures.end(); ++iter)
                        {
                                delete iter->second;
                        }
                        signatures.clear();
                        ULOGGER_DEBUG("Time emptying memory signatures trash = %f...", timer.ticks());
                }
                if(visualWords.size())
                {
                        if(this->isConnected())
                        {
                                //Only one query to the database
                                this->saveOrUpdate(uValues(visualWords));
                        }
 
                        for(std::map<int, VisualWord *>::iterator iter=visualWords.begin(); iter!=visualWords.end(); ++iter)
                        {
                                delete (*iter).second;
                        }
                        visualWords.clear();
                        ULOGGER_DEBUG("Time emptying memory visualWords trash = %f...", timer.ticks());
                }
 
                this->commit();
        }
 
        _emptyTrashesTime = totalTime.ticks();
        ULOGGER_DEBUG("Total time emptying trashes = %fs...", _emptyTrashesTime);
 
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::asyncSave(Signature * s)
{
        if(s)
        {
                UDEBUG("s=%d", s->id());
                _trashesMutex.lock();
                {
                        _trashSignatures.insert(std::pair<int, Signature*>(s->id(), s));
                }
                _trashesMutex.unlock();
        }
}
 
void DBDriver::asyncSave(VisualWord * vw)
{
        if(vw)
        {
                _trashesMutex.lock();
                {
                        _trashVisualWords.insert(std::pair<int, VisualWord*>(vw->id(), vw));
                }
                _trashesMutex.unlock();
        }
}
 
void DBDriver::saveOrUpdate(const std::vector<Signature *> & signatures)
{
        ULOGGER_DEBUG("");
        std::list<Signature *> toSave;
        std::list<Signature *> toUpdate;
        if(this->isConnected() && signatures.size())
        {
                for(std::vector<Signature *>::const_iterator i=signatures.begin(); i!=signatures.end();++i)
                {
                        if((*i)->isSaved())
                        {
                                toUpdate.push_back(*i);
                        }
                        else
                        {
                                toSave.push_back(*i);
                        }
                }
 
                if(toUpdate.size())
                {
                        this->updateQuery(toUpdate, _timestampUpdate);
                }
                if(toSave.size())
                {
                        this->saveQuery(toSave);
                }
        }
}
 
void DBDriver::saveOrUpdate(const std::vector<VisualWord *> & words) const
{
        ULOGGER_DEBUG("words.size=%d", (int)words.size());
        std::list<VisualWord *> toSave;
        std::list<VisualWord *> toUpdate;
        if(this->isConnected() && words.size())
        {
                for(std::vector<VisualWord *>::const_iterator i=words.begin(); i!=words.end();++i)
                {
                        if((*i)->isSaved())
                        {
                                toUpdate.push_back(*i);
                        }
                        else
                        {
                                toSave.push_back(*i);
                        }
                }
 
                if(toUpdate.size())
                {
                        this->updateQuery(toUpdate, _timestampUpdate);
                }
                if(toSave.size())
                {
                        this->saveQuery(toSave);
                }
        }
}
 
void DBDriver::addLink(const Link & link)
{
        _dbSafeAccessMutex.lock();
        this->addLinkQuery(link);
        _dbSafeAccessMutex.unlock();
}
void DBDriver::removeLink(int from, int to)
{
        this->executeNoResult(uFormat("DELETE FROM Link WHERE from_id=%d and to_id=%d", from, to).c_str());
}
void DBDriver::updateLink(const Link & link)
{
        _dbSafeAccessMutex.lock();
        this->updateLinkQuery(link);
        _dbSafeAccessMutex.unlock();
}
void DBDriver::updateOccupancyGrid(
                int nodeId,
                const cv::Mat & ground,
                const cv::Mat & obstacles,
                const cv::Mat & empty,
                float cellSize,
                const cv::Point3f & viewpoint)
{
        _dbSafeAccessMutex.lock();
        //just to make sure the occupancy grids are compressed for convenience
        SensorData data;
        data.setOccupancyGrid(ground, obstacles, empty, cellSize, viewpoint);
        this->updateOccupancyGridQuery(
                        nodeId,
                        data.gridGroundCellsCompressed(),
                        data.gridObstacleCellsCompressed(),
                        data.gridEmptyCellsCompressed(),
                        cellSize,
                        viewpoint);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::updateCalibration(int nodeId, const std::vector<CameraModel> & models, const std::vector<StereoCameraModel> & stereoModels)
{
        _dbSafeAccessMutex.lock();
        this->updateCalibrationQuery(
                        nodeId,
                        models,
                        stereoModels);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::updateDepthImage(int nodeId, const cv::Mat & image)
{
        _dbSafeAccessMutex.lock();
        this->updateDepthImageQuery(
                        nodeId,
                        image);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::updateLaserScan(int nodeId, const LaserScan & scan)
{
        _dbSafeAccessMutex.lock();
        this->updateLaserScanQuery(
                        nodeId,
                        scan);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::load(VWDictionary * dictionary, bool lastStateOnly) const
{
        _dbSafeAccessMutex.lock();
        this->loadQuery(dictionary, lastStateOnly);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::loadLastNodes(std::list<Signature *> & signatures) const
{
        _dbSafeAccessMutex.lock();
        this->loadLastNodesQuery(signatures);
        _dbSafeAccessMutex.unlock();
}
 
Signature * DBDriver::loadSignature(int id, bool * loadedFromTrash)
{
        std::list<int> ids;
        ids.push_back(id);
        std::list<Signature*> signatures;
        std::set<int> loadedFromTrashSet;
        loadSignatures(ids, signatures, &loadedFromTrashSet);
        if(loadedFromTrash && loadedFromTrashSet.size())
        {
                *loadedFromTrash = true;
        }
        if(!signatures.empty())
        {
                return signatures.front();
        }
        return 0;
}
void DBDriver::loadSignatures(const std::list<int> & signIds,
                std::list<Signature *> & signatures,
                std::set<int> * loadedFromTrash)
{
        UDEBUG("");
        // look up in the trash before the database
        std::list<int> ids = signIds;
        bool valueFound = false;
        _trashesMutex.lock();
        {
                for(std::list<int>::iterator iter = ids.begin(); iter != ids.end();)
                {
                        valueFound = false;
                        for(std::map<int, Signature*>::iterator sIter = _trashSignatures.begin(); sIter!=_trashSignatures.end();)
                        {
                                if(sIter->first == *iter)
                                {
                                        signatures.push_back(sIter->second);
                                        _trashSignatures.erase(sIter++);
 
                                        valueFound = true;
                                        break;
                                }
                                else
                                {
                                        ++sIter;
                                }
                        }
                        if(valueFound)
                        {
                                if(loadedFromTrash)
                                {
                                        loadedFromTrash->insert(*iter);
                                }
                                iter = ids.erase(iter);
                        }
                        else
                        {
                                ++iter;
                        }
                }
        }
        _trashesMutex.unlock();
        UDEBUG("");
        if(ids.size())
        {
                _dbSafeAccessMutex.lock();
                this->loadSignaturesQuery(ids, signatures);
                _dbSafeAccessMutex.unlock();
        }
}
 
void DBDriver::loadWords(const std::set<int> & wordIds, std::list<VisualWord *> & vws)
{
        // look up in the trash before the database
        std::set<int> ids = wordIds;
        std::map<int, VisualWord*>::iterator wIter;
        std::list<VisualWord *> puttedBack;
        _trashesMutex.lock();
        {
                if(_trashVisualWords.size())
                {
                        for(std::set<int>::iterator iter = ids.begin(); iter != ids.end();)
                        {
                                UASSERT(*iter>0);
                                wIter = _trashVisualWords.find(*iter);
                                if(wIter != _trashVisualWords.end())
                                {
                                        UDEBUG("put back word %d from trash", *iter);
                                        puttedBack.push_back(wIter->second);
                                        _trashVisualWords.erase(wIter);
                                        ids.erase(iter++);
                                }
                                else
                                {
                                        ++iter;
                                }
                        }
                }
        }
        _trashesMutex.unlock();
        if(ids.size())
        {
                _dbSafeAccessMutex.lock();
                this->loadWordsQuery(ids, vws);
                _dbSafeAccessMutex.unlock();
                uAppend(vws, puttedBack);
        }
        else if(puttedBack.size())
        {
                uAppend(vws, puttedBack);
        }
}
 
void DBDriver::loadNodeData(Signature * signature, bool images, bool scan, bool userData, bool occupancyGrid) const
{
        std::list<Signature *> signatures;
        signatures.push_back(signature);
        this->loadNodeData(signatures, images, scan, userData, occupancyGrid);
}
 
void DBDriver::loadNodeData(std::list<Signature *> & signatures, bool images, bool scan, bool userData, bool occupancyGrid) const
{
        // Don't look in the trash, we assume that if we want to load
        // data of a signature, it is not in thrash! Print an error if so.
        _trashesMutex.lock();
        if(_trashSignatures.size())
        {
                for(std::list<Signature *>::iterator iter=signatures.begin(); iter!=signatures.end(); ++iter)
                {
                        UASSERT(*iter != 0);
                        UASSERT_MSG(!uContains(_trashSignatures, (*iter)->id()), uFormat("Signature %d should not be used when transferred to trash!!!!", (*iter)->id()).c_str());
                }
        }
        _trashesMutex.unlock();
 
        _dbSafeAccessMutex.lock();
        this->loadNodeDataQuery(signatures, images, scan, userData, occupancyGrid);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getNodeData(
                int signatureId,
                SensorData & data,
                bool images, bool scan, bool userData, bool occupancyGrid) const
{
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                const Signature * s = _trashSignatures.at(signatureId);
                if((!s->isSaved() ||
                        ((!images || !s->sensorData().imageCompressed().empty()) &&
                         (!scan || !s->sensorData().laserScanCompressed().isEmpty()) &&
                         (!userData || !s->sensorData().userDataCompressed().empty()) &&
                         (!occupancyGrid || s->sensorData().gridCellSize() != 0.0f))))
                {
                        data = (SensorData)s->sensorData();
                        if(!images)
                        {
                                data.setRGBDImage(cv::Mat(), cv::Mat(), std::vector<CameraModel>());
                        }
                        if(!scan)
                        {
                                data.setLaserScan(LaserScan());
                        }
                        if(!userData)
                        {
                                data.setUserData(cv::Mat());
                        }
                        if(!occupancyGrid)
                        {
                                data.setOccupancyGrid(cv::Mat(), cv::Mat(), cv::Mat(), 0, cv::Point3f());
                        }
                        found = true;
                }
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                std::list<Signature *> signatures;
                Signature tmp(signatureId);
                signatures.push_back(&tmp);
                loadNodeDataQuery(signatures, images, scan, userData, occupancyGrid);
                data = signatures.front()->sensorData();
                _dbSafeAccessMutex.unlock();
        }
}
 
bool DBDriver::getCalibration(
                int signatureId,
                std::vector<CameraModel> & models,
                std::vector<StereoCameraModel> & stereoModels) const
{
        UDEBUG("");
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                models = _trashSignatures.at(signatureId)->sensorData().cameraModels();
                stereoModels = _trashSignatures.at(signatureId)->sensorData().stereoCameraModels();
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                found = this->getCalibrationQuery(signatureId, models, stereoModels);
                _dbSafeAccessMutex.unlock();
        }
        return found;
}
 
bool DBDriver::getLaserScanInfo(
                int signatureId,
                LaserScan & info) const
{
        UDEBUG("");
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                info = _trashSignatures.at(signatureId)->sensorData().laserScanCompressed();
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                found = this->getLaserScanInfoQuery(signatureId, info);
                _dbSafeAccessMutex.unlock();
        }
        return found;
}
 
bool DBDriver::getNodeInfo(
                int signatureId,
                Transform & pose,
                int & mapId,
                int & weight,
                std::string & label,
                double & stamp,
                Transform & groundTruthPose,
                std::vector<float> & velocity,
                GPS & gps,
                EnvSensors & sensors) const
{
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                pose = _trashSignatures.at(signatureId)->getPose().clone();
                mapId = _trashSignatures.at(signatureId)->mapId();
                weight = _trashSignatures.at(signatureId)->getWeight();
                label = std::string(_trashSignatures.at(signatureId)->getLabel());
                stamp = _trashSignatures.at(signatureId)->getStamp();
                groundTruthPose = _trashSignatures.at(signatureId)->getGroundTruthPose().clone();
                velocity = std::vector<float>(_trashSignatures.at(signatureId)->getVelocity());
                gps = GPS(_trashSignatures.at(signatureId)->sensorData().gps());
                sensors = EnvSensors(_trashSignatures.at(signatureId)->sensorData().envSensors());
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                found = this->getNodeInfoQuery(signatureId, pose, mapId, weight, label, stamp, groundTruthPose, velocity, gps, sensors);
                _dbSafeAccessMutex.unlock();
        }
        return found;
}
 
void DBDriver::loadLinks(int signatureId, std::multimap<int, Link> & links, Link::Type type) const
{
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                const Signature * s = _trashSignatures.at(signatureId);
                UASSERT(s != 0);
                for(std::map<int, Link>::const_iterator nIter = s->getLinks().begin();
                                nIter!=s->getLinks().end();
                                ++nIter)
                {
                        if(type == Link::kAllWithoutLandmarks || type == Link::kAllWithLandmarks || nIter->second.type() == type)
                        {
                                links.insert(*nIter);
                        }
                }
                if(type == Link::kLandmark || type == Link::kAllWithLandmarks)
                {
                        links.insert(s->getLandmarks().begin(), s->getLandmarks().end());
                }
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                this->loadLinksQuery(signatureId, links, type);
                _dbSafeAccessMutex.unlock();
        }
}
 
void DBDriver::getWeight(int signatureId, int & weight) const
{
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                weight = _trashSignatures.at(signatureId)->getWeight();
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                this->getWeightQuery(signatureId, weight);
                _dbSafeAccessMutex.unlock();
        }
}
 
void DBDriver::getLastNodeIds(std::set<int> & ids) const
{
        _dbSafeAccessMutex.lock();
        this->getLastNodeIdsQuery(ids);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getAllNodeIds(std::set<int> & ids, bool ignoreChildren, bool ignoreBadSignatures, bool ignoreIntermediateNodes) const
{
        // look in the trash
        _trashesMutex.lock();
        if(_trashSignatures.size())
        {
                for(std::map<int, Signature*>::const_iterator sIter = _trashSignatures.begin(); sIter!=_trashSignatures.end(); ++sIter)
                {
                        bool hasNeighbors = !ignoreChildren;
                        if(ignoreChildren)
                        {
                                for(std::map<int, Link>::const_iterator nIter = sIter->second->getLinks().begin();
                                                nIter!=sIter->second->getLinks().end();
                                                ++nIter)
                                {
                                        if(nIter->second.type() == Link::kNeighbor ||
                                           nIter->second.type() == Link::kNeighborMerged)
                                        {
                                                hasNeighbors = true;
                                                break;
                                        }
                                }
                        }
                        if(hasNeighbors && (!ignoreIntermediateNodes || sIter->second->getWeight() != -1))
                        {
                                ids.insert(sIter->first);
                        }
                }
 
                std::vector<int> keys = uKeys(_trashSignatures);
 
        }
        _trashesMutex.unlock();
 
        _dbSafeAccessMutex.lock();
        this->getAllNodeIdsQuery(ids, ignoreChildren, ignoreBadSignatures, ignoreIntermediateNodes);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getAllLinks(std::multimap<int, Link> & links, bool ignoreNullLinks, bool withLandmarks) const
{
        _dbSafeAccessMutex.lock();
        this->getAllLinksQuery(links, ignoreNullLinks, withLandmarks);
        _dbSafeAccessMutex.unlock();
 
        // look in the trash
        _trashesMutex.lock();
        if(_trashSignatures.size())
        {
                for(std::map<int, Signature*>::const_iterator iter=_trashSignatures.begin(); iter!=_trashSignatures.end(); ++iter)
                {
                        links.erase(iter->first);
                        for(std::map<int, Link>::const_iterator jter=iter->second->getLinks().begin();
                                jter!=iter->second->getLinks().end();
                                ++jter)
                        {
                                if(!ignoreNullLinks || jter->second.isValid())
                                {
                                        links.insert(std::make_pair(iter->first, jter->second));
                                }
                        }
                        if(withLandmarks)
                        {
                                for(std::map<int, Link>::const_iterator jter=iter->second->getLandmarks().begin();
                                        jter!=iter->second->getLandmarks().end();
                                        ++jter)
                                {
                                        if(!ignoreNullLinks || jter->second.isValid())
                                        {
                                                links.insert(std::make_pair(iter->first, jter->second));
                                        }
                                }
                        }
                }
        }
        _trashesMutex.unlock();
}
 
void DBDriver::getLastNodeId(int & id) const
{
        // look in the trash
        _trashesMutex.lock();
        if(_trashSignatures.size())
        {
                id = _trashSignatures.rbegin()->first;
        }
        _trashesMutex.unlock();
 
        _dbSafeAccessMutex.lock();
        this->getLastIdQuery("Node", id);
        int statisticsId = 0;
        if(uStrNumCmp(this->getDatabaseVersion(), "0.11.11") >= 0)
        {
                this->getLastIdQuery("Statistics", statisticsId);
                if(statisticsId > id)
                {
                        id = statisticsId;
                }
        }
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getLastMapId(int & mapId) const
{
        // look in the trash
        _trashesMutex.lock();
        if(_trashSignatures.size())
        {
                mapId = _trashSignatures.rbegin()->second->mapId();
        }
        _trashesMutex.unlock();
 
        _dbSafeAccessMutex.lock();
        this->getLastIdQuery("Node", mapId, "map_id");
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getLastWordId(int & id) const
{
        // look in the trash
        _trashesMutex.lock();
        if(_trashVisualWords.size())
        {
                id = _trashVisualWords.rbegin()->first;
        }
        _trashesMutex.unlock();
 
        _dbSafeAccessMutex.lock();
        this->getLastIdQuery("Word", id);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::getInvertedIndexNi(int signatureId, int & ni) const
{
        bool found = false;
        // look in the trash
        _trashesMutex.lock();
        if(uContains(_trashSignatures, signatureId))
        {
                ni = _trashSignatures.at(signatureId)->getWords().size();
                found = true;
        }
        _trashesMutex.unlock();
 
        if(!found)
        {
                _dbSafeAccessMutex.lock();
                this->getInvertedIndexNiQuery(signatureId, ni);
                _dbSafeAccessMutex.unlock();
        }
}
 
void DBDriver::getNodesObservingLandmark(int landmarkId, std::map<int, Link> & nodes) const
{
        if(landmarkId < 0)
        {
                // look in the trash
                _trashesMutex.lock();
                for(std::map<int, Signature*>::const_iterator sIter = _trashSignatures.begin(); sIter!=_trashSignatures.end(); ++sIter)
                {
                        std::map<int, Link>::const_iterator kter = sIter->second->getLandmarks().find(landmarkId);
                        if(kter != sIter->second->getLandmarks().end())
                        {
                                nodes.insert(std::make_pair(sIter->second->id(), kter->second));
                        }
                }
                _trashesMutex.unlock();
 
                // then look in the database
                _dbSafeAccessMutex.lock();
                this->getNodesObservingLandmarkQuery(landmarkId, nodes);
                _dbSafeAccessMutex.unlock();
        }
        else
        {
                UWARN("Can't search with an empty label!");
        }
}
 
void DBDriver::getNodeIdByLabel(const std::string & label, int & id) const
{
        if(!label.empty())
        {
                int idFound = 0;
                // look in the trash
                _trashesMutex.lock();
                for(std::map<int, Signature*>::const_iterator sIter = _trashSignatures.begin(); sIter!=_trashSignatures.end(); ++sIter)
                {
                        if(sIter->second->getLabel().compare(label) == 0)
                        {
                                idFound = sIter->first;
                                break;
                        }
                }
                _trashesMutex.unlock();
 
                // then look in the database
                if(idFound == 0)
                {
                        _dbSafeAccessMutex.lock();
                        this->getNodeIdByLabelQuery(label, id);
                        _dbSafeAccessMutex.unlock();
                }
                else
                {
                        id = idFound;
                }
        }
        else
        {
                UWARN("Can't search with an empty label!");
        }
}
 
void DBDriver::getAllLabels(std::map<int, std::string> & labels) const
{
        // look in the trash
        _trashesMutex.lock();
        for(std::map<int, Signature*>::const_iterator sIter = _trashSignatures.begin(); sIter!=_trashSignatures.end(); ++sIter)
        {
                if(!sIter->second->getLabel().empty())
                {
                        labels.insert(std::make_pair(sIter->first, sIter->second->getLabel()));
                }
        }
        _trashesMutex.unlock();
 
        // then look in the database
        _dbSafeAccessMutex.lock();
        this->getAllLabelsQuery(labels);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::addInfoAfterRun(
                int stMemSize,
                int lastSignAdded,
                int processMemUsed,
                int databaseMemUsed,
                int dictionarySize,
                const ParametersMap & parameters) const
{
        ULOGGER_DEBUG("");
        if(this->isConnected())
        {
                std::stringstream query;
                if(uStrNumCmp(this->getDatabaseVersion(), "0.11.8") >= 0)
                {
                        std::string param = Parameters::serialize(parameters);
                        if(uStrNumCmp(this->getDatabaseVersion(), "0.11.11") >= 0)
                        {
                                query << "INSERT INTO Info(STM_size,last_sign_added,process_mem_used,database_mem_used,dictionary_size,parameters) values("
                                          << stMemSize << ","
                                          << lastSignAdded << ","
                                          << processMemUsed << ","
                                          << databaseMemUsed << ","
                                          << dictionarySize << ","
                                          "\"" << param.c_str() << "\");";
                        }
                        else
                        {
                                query << "INSERT INTO Statistics(STM_size,last_sign_added,process_mem_used,database_mem_used,dictionary_size,parameters) values("
                                          << stMemSize << ","
                                          << lastSignAdded << ","
                                          << processMemUsed << ","
                                          << databaseMemUsed << ","
                                          << dictionarySize << ","
                                          "\"" << param.c_str() << "\");";
                        }
                }
                else
                {
                        query << "INSERT INTO Statistics(STM_size,last_sign_added,process_mem_used,database_mem_used,dictionary_size) values("
                                  << stMemSize << ","
                                  << lastSignAdded << ","
                                  << processMemUsed << ","
                                  << databaseMemUsed << ","
                                  << dictionarySize << ");";
                }
 
                this->executeNoResultQuery(query.str());
        }
}
 
void DBDriver::addStatistics(const Statistics & statistics, bool saveWmState) const
{
        _dbSafeAccessMutex.lock();
        addStatisticsQuery(statistics, saveWmState);
        _dbSafeAccessMutex.unlock();
}
 
void DBDriver::savePreviewImage(const cv::Mat & image) const
{
        _dbSafeAccessMutex.lock();
        savePreviewImageQuery(image);
        _dbSafeAccessMutex.unlock();
}
 
cv::Mat DBDriver::loadPreviewImage() const
{
        _dbSafeAccessMutex.lock();
        cv::Mat image = loadPreviewImageQuery();
        _dbSafeAccessMutex.unlock();
        return image;
}
 
void DBDriver::saveOptimizedPoses(const std::map<int, Transform> & optimizedPoses, const Transform & lastlocalizationPose) const
{
        _dbSafeAccessMutex.lock();
        saveOptimizedPosesQuery(optimizedPoses, lastlocalizationPose);
        _dbSafeAccessMutex.unlock();
}
std::map<int, Transform> DBDriver::loadOptimizedPoses(Transform * lastlocalizationPose) const
{
        _dbSafeAccessMutex.lock();
        std::map<int, Transform> poses = loadOptimizedPosesQuery(lastlocalizationPose);
        _dbSafeAccessMutex.unlock();
        return poses;
}
 
void DBDriver::save2DMap(const cv::Mat & map, float xMin, float yMin, float cellSize) const
{
        _dbSafeAccessMutex.lock();
        save2DMapQuery(map, xMin, yMin, cellSize);
        _dbSafeAccessMutex.unlock();
}
 
cv::Mat DBDriver::load2DMap(float & xMin, float & yMin, float & cellSize) const
{
        _dbSafeAccessMutex.lock();
        cv::Mat map = load2DMapQuery(xMin, yMin, cellSize);
        _dbSafeAccessMutex.unlock();
        return map;
}
 
void DBDriver::saveOptimizedMesh(
                        const cv::Mat & cloud,
                        const std::vector<std::vector<std::vector<RTABMAP_PCL_INDEX> > > & polygons,
#if PCL_VERSION_COMPARE(>=, 1, 8, 0)
                        const std::vector<std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> > > & texCoords,
#else
                        const std::vector<std::vector<Eigen::Vector2f> > & texCoords,
#endif
                        const cv::Mat & textures) const
{
        _dbSafeAccessMutex.lock();
        saveOptimizedMeshQuery(cloud, polygons, texCoords, textures);
        _dbSafeAccessMutex.unlock();
}
 
cv::Mat DBDriver::loadOptimizedMesh(
                                std::vector<std::vector<std::vector<RTABMAP_PCL_INDEX> > > * polygons,
#if PCL_VERSION_COMPARE(>=, 1, 8, 0)
                                std::vector<std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> > > * texCoords,
#else
                                std::vector<std::vector<Eigen::Vector2f> > * texCoords,
#endif
                                cv::Mat * textures) const
{
        _dbSafeAccessMutex.lock();
        cv::Mat cloud = loadOptimizedMeshQuery(polygons, texCoords, textures);
        _dbSafeAccessMutex.unlock();
        return cloud;
}
 
void DBDriver::generateGraph(
                const std::string & fileName,
                const std::set<int> & idsInput,
                const std::map<int, Signature *> & otherSignatures)
{
        if(this->isConnected())
        {
                if(!fileName.empty())
                {
                        FILE* fout = 0;
                        #ifdef _MSC_VER
                                fopen_s(&fout, fileName.c_str(), "w");
                        #else
                                fout = fopen(fileName.c_str(), "w");
                        #endif
 
                         if (!fout)
                         {
                                 UERROR("Cannot open file %s!", fileName.c_str());
                                 return;
                         }
 
                         std::set<int> ids;
                         if(idsInput.size() == 0)
                         {
                                 this->getAllNodeIds(ids);
                                 UDEBUG("ids.size()=%d", ids.size());
                                 for(std::map<int, Signature*>::const_iterator iter=otherSignatures.begin(); iter!=otherSignatures.end(); ++iter)
                                 {
                                         ids.insert(iter->first);
                                 }
                         }
                         else
                         {
                                 ids = idsInput;
                         }
 
                         const char * colorG = "green";
                         const char * colorP = "pink";
                         const char * colorNM = "blue";
                         UINFO("Generating map with %d locations", ids.size());
                         fprintf(fout, "digraph G {\n");
                         for(std::set<int>::iterator i=ids.begin(); i!=ids.end(); ++i)
                         {
                                 if(otherSignatures.find(*i) == otherSignatures.end())
                                 {
                                         int id = *i;
                                         std::multimap<int, Link> links;
                                         this->loadLinks(id, links);
                                         int weight = 0;
                                         this->getWeight(id, weight);
                                         for(std::multimap<int, Link>::iterator iter = links.begin(); iter!=links.end(); ++iter)
                                         {
                                                 int weightNeighbor = 0;
                                                 if(otherSignatures.find(iter->first) == otherSignatures.end())
                                                 {
                                                         this->getWeight(iter->first, weightNeighbor);
                                                 }
                                                 else
                                                 {
                                                         weightNeighbor = otherSignatures.find(iter->first)->second->getWeight();
                                                 }
                                                 //UDEBUG("Add neighbor link from %d to %d", id, iter->first);
                                                 if(iter->second.type() == Link::kNeighbor)
                                                 {
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\"\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor);
                                                 }
                                                 else if(iter->second.type() == Link::kNeighborMerged)
                                                 {
                                                         //merged neighbor
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"M\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorNM);
                                                 }
                                                 else if(iter->first > id)
                                                 {
                                                         //loop
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"L\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorG);
                                                 }
                                                 else
                                                 {
                                                         //child
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"C\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorP);
                                                 }
                                         }
                                 }
                         }
                         for(std::map<int, Signature*>::const_iterator i=otherSignatures.begin(); i!=otherSignatures.end(); ++i)
                         {
                                 if(ids.find(i->first) != ids.end())
                                 {
                                         int id = i->second->id();
                                         const std::multimap<int, Link> & links = i->second->getLinks();
                                         int weight = i->second->getWeight();
                                         for(std::multimap<int, Link>::const_iterator iter = links.begin(); iter!=links.end(); ++iter)
                                         {
                                                 int weightNeighbor = 0;
                                                 const Signature * s = uValue(otherSignatures, iter->first, (Signature*)0);
                                                 if(s)
                                                 {
                                                         weightNeighbor = s->getWeight();
                                                 }
                                                 else
                                                 {
                                                         this->getWeight(iter->first, weightNeighbor);
                                                 }
                                                 //UDEBUG("Add neighbor link from %d to %d", id, iter->first);
                                                 if(iter->second.type() == Link::kNeighbor)
                                                 {
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\"\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor);
                                                 }
                                                 else if(iter->second.type() == Link::kNeighborMerged)
                                                 {
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"M\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorNM);
                                                 }
                                                 else if(iter->first > id)
                                                 {
                                                         //loop
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"L\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorG);
                                                 }
                                                 else if(iter->first != id)
                                                 {
                                                         //child
                                                         fprintf(fout, "   \"%d\\n%d\" -> \"%d\\n%d\" [label=\"C\", fontcolor=%s, fontsize=8];\n",
                                                                         id,
                                                                         weight,
                                                                         iter->first,
                                                                         weightNeighbor,
                                                                         colorP);
                                                 }
                                         }
                                 }
                         }
                         fprintf(fout, "}\n");
                         fclose(fout);
                         UINFO("Graph saved to \"%s\" (Tip: $ neato -Tpdf \"%s\" -o out.pdf)", fileName.c_str(), fileName.c_str());
                }
        }
}
 
} // namespace rtabmap