CRawlog.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 "obs-precomp.h"  // Precompiled headers
 
#include <mrpt/system/filesystem.h>
#include <mrpt/obs/CRawlog.h>
#include <mrpt/io/CFileInputStream.h>
#include <mrpt/io/CFileGZInputStream.h>
#include <mrpt/io/CFileGZOutputStream.h>
#include <mrpt/serialization/CArchive.h>
 
using namespace mrpt;
using namespace mrpt::io;
using namespace mrpt::obs;
using namespace mrpt::poses;
using namespace mrpt::system;
using namespace mrpt::serialization;
 
IMPLEMENTS_SERIALIZABLE(CRawlog, CSerializable, mrpt::obs)
 
// ctor
CRawlog::CRawlog() : m_seqOfActObs(), m_commentTexts() {}
// dtor
CRawlog::~CRawlog() { clear(); }
void CRawlog::clear()
{
        m_seqOfActObs.clear();
        m_commentTexts.text.clear();
}
 
void CRawlog::addObservations(CSensoryFrame& observations)
{
        m_seqOfActObs.push_back(
                std::dynamic_pointer_cast<CSerializable>(
                        observations.duplicateGetSmartPtr()));
}
 
void CRawlog::addActions(CActionCollection& actions)
{
        m_seqOfActObs.push_back(
                std::dynamic_pointer_cast<CSerializable>(
                        actions.duplicateGetSmartPtr()));
}
 
void CRawlog::addActionsMemoryReference(const CActionCollection::Ptr& action)
{
        m_seqOfActObs.push_back(action);
}
 
void CRawlog::addObservationsMemoryReference(
        const CSensoryFrame::Ptr& observations)
{
        m_seqOfActObs.push_back(observations);
}
void CRawlog::addGenericObject(const CSerializable::Ptr& obj)
{
        m_seqOfActObs.push_back(obj);
}
 
void CRawlog::addObservationMemoryReference(
        const CObservation::Ptr& observation)
{
        if (IS_CLASS(observation, CObservationComment))
        {
                CObservationComment::Ptr o =
                        std::dynamic_pointer_cast<CObservationComment>(observation);
                m_commentTexts = *o;
        }
        else
                m_seqOfActObs.push_back(observation);
}
 
void CRawlog::addAction(CAction& action)
{
        CActionCollection::Ptr temp =
                mrpt::make_aligned_shared<CActionCollection>();
        temp->insert(action);
        m_seqOfActObs.push_back(temp);
}
 
size_t CRawlog::size() const { return m_seqOfActObs.size(); }
CActionCollection::Ptr CRawlog::getAsAction(size_t index) const
{
        MRPT_START
 
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
 
        CSerializable::Ptr obj = m_seqOfActObs[index];
 
        if (obj->GetRuntimeClass() == CLASS_ID(CActionCollection))
                return std::dynamic_pointer_cast<CActionCollection>(obj);
        else
                THROW_EXCEPTION_FMT(
                        "Element at index %i is not a CActionCollection", (int)index);
        MRPT_END
}
 
CObservation::Ptr CRawlog::getAsObservation(size_t index) const
{
        MRPT_START
 
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
 
        CSerializable::Ptr obj = m_seqOfActObs[index];
 
        if (obj->GetRuntimeClass()->derivedFrom(CLASS_ID(CObservation)))
                return std::dynamic_pointer_cast<CObservation>(obj);
        else
                THROW_EXCEPTION_FMT(
                        "Element at index %i is not a CObservation", (int)index);
        MRPT_END
}
 
CSerializable::Ptr CRawlog::getAsGeneric(size_t index) const
{
        MRPT_START
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
 
        return m_seqOfActObs[index];
        MRPT_END
}
 
CRawlog::TEntryType CRawlog::getType(size_t index) const
{
        MRPT_START
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
 
        const CSerializable::Ptr& obj = m_seqOfActObs[index];
 
        if (obj->GetRuntimeClass()->derivedFrom(CLASS_ID(CObservation)))
                return etObservation;
        else if (obj->GetRuntimeClass() == CLASS_ID(CActionCollection))
                return etActionCollection;
        else if (obj->GetRuntimeClass() == CLASS_ID(CSensoryFrame))
                return etSensoryFrame;
        else
                return etOther;
 
        MRPT_END
}
 
CSensoryFrame::Ptr CRawlog::getAsObservations(size_t index) const
{
        MRPT_START
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
 
        CSerializable::Ptr obj = m_seqOfActObs[index];
 
        if (obj->GetRuntimeClass()->derivedFrom(CLASS_ID(CSensoryFrame)))
                return std::dynamic_pointer_cast<CSensoryFrame>(obj);
        else
                THROW_EXCEPTION_FMT(
                        "Element at index %i is not a CSensoryFrame", (int)index);
        MRPT_END
}
 
uint8_t CRawlog::serializeGetVersion() const { return 1; }
void CRawlog::serializeTo(mrpt::serialization::CArchive& out) const
{
        out.WriteAs<uint32_t>(m_seqOfActObs.size());
        for (const auto& a : m_seqOfActObs) out << a;
        out << m_commentTexts;
}
 
void CRawlog::serializeFrom(mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                case 1:
                {
                        clear();
                        m_seqOfActObs.resize(in.ReadAs<uint32_t>());
                        for (auto& a : m_seqOfActObs) a = in.ReadObject();
                        in >> m_commentTexts;
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
bool CRawlog::loadFromRawLogFile(
        const std::string& fileName, bool non_obs_objects_are_legal)
{
        // Open for read.
        CFileGZInputStream fi(fileName);
        if (!fi.fileOpenCorrectly()) return false;
        auto fs = archiveFrom(fi);
 
        clear();  // Clear first
 
        // OK: read objects:
        bool keepReading = true;
        while (keepReading)
        {
                CSerializable::Ptr newObj;
                try
                {
                        fs >> newObj;
                        bool add_obj = false;
                        // Check type:
                        if (newObj->GetRuntimeClass() == CLASS_ID(CRawlog))
                        {
                                // It is an entire object: Copy and finish:
                                CRawlog::Ptr ao = std::dynamic_pointer_cast<CRawlog>(newObj);
                                this->swap(*ao);
                                return true;
                        }
                        else if (
                                newObj->GetRuntimeClass()->derivedFrom(CLASS_ID(CObservation)))
                        {
                                if (IS_CLASS(newObj, CObservationComment))
                                {
                                        CObservationComment::Ptr o =
                                                std::dynamic_pointer_cast<CObservationComment>(newObj);
                                        m_commentTexts = *o;
                                }
                                else
                                {
                                        add_obj = true;
                                }
                        }
                        else if (newObj->GetRuntimeClass() == CLASS_ID(CSensoryFrame))
                        {
                                add_obj = true;
                        }
                        else if (newObj->GetRuntimeClass() == CLASS_ID(CActionCollection))
                        {
                                add_obj = true;
                        }
                        else
                        {
                                // Other classes:
                                if (non_obs_objects_are_legal)
                                {
                                        add_obj = true;
                                }
                                else
                                {
                                        keepReading = false;
                                }
                        }
                        if (add_obj) m_seqOfActObs.push_back(newObj);
                }
                catch (CExceptionEOF&)
                {  // EOF, just finish the loop
                        keepReading = false;
                }
                catch (std::exception& e)
                {
                        std::cerr << e.what() << std::endl;
                        keepReading = false;
                }
                catch (...)
                {
                        keepReading = false;
                }
        }
        return true;
}
 
void CRawlog::remove(size_t index)
{
        MRPT_START
        if (index >= m_seqOfActObs.size()) THROW_EXCEPTION("Index out of bounds");
        m_seqOfActObs.erase(m_seqOfActObs.begin() + index);
        MRPT_END
}
 
void CRawlog::remove(size_t first_index, size_t last_index)
{
        MRPT_START
        if (first_index >= m_seqOfActObs.size() ||
                last_index >= m_seqOfActObs.size())
                THROW_EXCEPTION("Index out of bounds");
        m_seqOfActObs.erase(
                m_seqOfActObs.begin() + first_index,
                m_seqOfActObs.begin() + last_index + 1);
        MRPT_END
}
 
bool CRawlog::saveToRawLogFile(const std::string& fileName) const
{
        try
        {
                CFileGZOutputStream fo(fileName);
                auto f = archiveFrom(fo);
                if (!m_commentTexts.text.empty()) f << m_commentTexts;
                for (size_t i = 0; i < m_seqOfActObs.size(); i++)
                        f << *m_seqOfActObs[i];
                return true;
        }
        catch (...)
        {
                return false;
        }
}
 
void CRawlog::swap(CRawlog& obj)
{
        if (this == &obj) return;
        m_seqOfActObs.swap(obj.m_seqOfActObs);
        std::swap(m_commentTexts, obj.m_commentTexts);
}
 
bool CRawlog::readActionObservationPair(
        CArchive& inStream, CActionCollection::Ptr& action,
        CSensoryFrame::Ptr& observations, size_t& rawlogEntry)
{
        try
        {
                // Load pose change from the rawlog:
                action.reset();
                while (!action)
                {
                        CSerializable::Ptr obj;
                        inStream >> obj;
                        if (obj->GetRuntimeClass() == CLASS_ID(CActionCollection))
                        {
                                action = std::dynamic_pointer_cast<CActionCollection>(obj);
                        }
                        else
                        {
                                obj.reset();
                        }
                        rawlogEntry++;
                };
 
                // Load sensory frame from the rawlog:
                observations.reset();
                while (!observations)
                {
                        CSerializable::Ptr obj;
                        inStream >> obj;
                        if (obj->GetRuntimeClass() == CLASS_ID(CSensoryFrame))
                        {
                                observations = std::dynamic_pointer_cast<CSensoryFrame>(obj);
                        }
                        else
                        {
                                obj.reset();
                        }
                        rawlogEntry++;
                }
                return true;
        }
        catch (CExceptionEOF&)
        {
                return false;
        }
        catch (std::exception& e)
        {
                std::cerr << "[CRawlog::readActionObservationPair] Found exception:"
                                  << std::endl
                                  << e.what() << std::endl;
                return false;
        }
        catch (...)
        {
                std::cerr << "Untyped exception reading rawlog file!!" << std::endl;
                return false;
        }
}
 
bool CRawlog::getActionObservationPairOrObservation(
        CArchive& inStream, CActionCollection::Ptr& action,
        CSensoryFrame::Ptr& observations, CObservation::Ptr& observation,
        size_t& rawlogEntry)
{
        try
        {
                // Load pose change from the rawlog:
                observations.reset();
                observation.reset();
                action.reset();
                while (!action)
                {
                        CSerializable::Ptr obj;
                        inStream >> obj;
                        if (IS_CLASS(obj, CActionCollection))
                        {
                                action = std::dynamic_pointer_cast<CActionCollection>(obj);
                        }
                        else if (IS_DERIVED(obj, CObservation))
                        {
                                observation = std::dynamic_pointer_cast<CObservation>(obj);
                                rawlogEntry++;
                                return true;
                        }
                        else
                                obj.reset();
                        rawlogEntry++;
                };
 
                // Load sensory frame from the rawlog:
                observations.reset();
                while (!observations)
                {
                        CSerializable::Ptr obj;
                        inStream >> obj;
                        if (obj->GetRuntimeClass() == CLASS_ID(CSensoryFrame))
                        {
                                observations = std::dynamic_pointer_cast<CSensoryFrame>(obj);
                        }
                        rawlogEntry++;
                }
                return true;
        }
        catch (CExceptionEOF&)
        {
                return false;
        }
        catch (std::exception& e)
        {
                std::cerr << "[CRawlog::readActionObservationPair] Found exception:"
                                  << std::endl
                                  << e.what() << std::endl;
                return false;
        }
        catch (...)
        {
                std::cerr << "Untyped exception reading rawlog file!!" << std::endl;
                return false;
        }
}
 
void CRawlog::findObservationsByClassInRange(
        mrpt::system::TTimeStamp time_start, mrpt::system::TTimeStamp time_end,
        const mrpt::rtti::TRuntimeClassId* class_type,
        TListTimeAndObservations& out_found, size_t guess_start_position) const
{
        MRPT_UNUSED_PARAM(guess_start_position);
        MRPT_START
 
        out_found.clear();
 
        if (m_seqOfActObs.empty()) return;
 
        // Find the first appearance of time_start:
        // ---------------------------------------------------
        TListObjects::const_iterator first = m_seqOfActObs.begin();
        const TListObjects::const_iterator last = m_seqOfActObs.end();
        {
                // The following is based on lower_bound:
                size_t count, step;
                count = std::distance(first, last);
                while (count > 0)
                {
                        TListObjects::const_iterator it = first;
                        step = count / 2;
                        std::advance(it, step);
 
                        // The comparison function:
                        TTimeStamp this_timestamp;
                        if ((*it)->GetRuntimeClass()->derivedFrom(CLASS_ID(CObservation)))
                        {
                                CObservation::Ptr o =
                                        std::dynamic_pointer_cast<CObservation>(*it);
                                this_timestamp = o->timestamp;
                                ASSERT_(this_timestamp != INVALID_TIMESTAMP);
                        }
                        else
                                THROW_EXCEPTION(
                                        "Element found which is not derived from CObservation");
 
                        if (this_timestamp < time_start)  // *it < time_start
                        {
                                first = ++it;
                                count -= step + 1;
                        }
                        else
                                count = step;
                }
                // "first" is our guy
        }
 
        // Iterate until we get out of the time window:
        while (first != last)
        {
                TTimeStamp this_timestamp;
                if ((*first)->GetRuntimeClass()->derivedFrom(CLASS_ID(CObservation)))
                {
                        CObservation::Ptr o =
                                std::dynamic_pointer_cast<CObservation>(*first);
                        this_timestamp = o->timestamp;
                        ASSERT_(this_timestamp != INVALID_TIMESTAMP);
 
                        if (this_timestamp < time_end)
                        {
                                if (o->GetRuntimeClass()->derivedFrom(class_type))
                                        out_found.insert(TTimeObservationPair(this_timestamp, o));
                        }
                        else
                        {
                                break;  // end of time window!
                        }
                }
                else
                        THROW_EXCEPTION(
                                "Element found which is not derived from CObservation");
 
                first++;
        }
 
        MRPT_END
}
 
bool CRawlog::getActionObservationPair(
        CActionCollection::Ptr& action, CSensoryFrame::Ptr& observations,
        size_t& rawlogEntry) const
{
        try
        {
                while (getType(rawlogEntry) != CRawlog::etActionCollection)
                {
                        rawlogEntry++;
                }
                action = getAsAction(rawlogEntry++);
 
                while (getType(rawlogEntry) != CRawlog::etSensoryFrame)
                {
                        rawlogEntry++;
                }
                observations = getAsObservations(rawlogEntry++);
 
                return true;
        }
        catch (std::exception&)
        {
                return false;
        }
        catch (...)
        {
                std::cerr << "Untyped exception getting act-obs pair from rawlog!!"
                                  << std::endl;
                return false;
        }
}
 
void CRawlog::getCommentText(std::string& t) const { t = m_commentTexts.text; }
std::string CRawlog::getCommentText() const { return m_commentTexts.text; }
void CRawlog::getCommentTextAsConfigFile(
        mrpt::config::CConfigFileMemory& memCfg) const
{
        memCfg.setContent(m_commentTexts.text);
}
 
void CRawlog::setCommentText(const std::string& t) { m_commentTexts.text = t; }
std::string CRawlog::detectImagesDirectory(const std::string& str)
{
        const std::string rawlog_path = extractFileDirectory(str);
        std::string temptative_img_path =
                rawlog_path + extractFileName(str) + std::string("_Images");
        if (mrpt::system::fileExists(temptative_img_path))
                return temptative_img_path;
        else if (
                mrpt::system::fileExists(
                        temptative_img_path =
                                (rawlog_path + extractFileName(str) + std::string("_images"))))
                return temptative_img_path;
        else if (
                mrpt::system::fileExists(
                        temptative_img_path =
                                (rawlog_path + extractFileName(str) + std::string("_IMAGES"))))
                return temptative_img_path;
        else
                return rawlog_path + "Images";
}