LaserScansMemory.cpp

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2022
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "LaserScansMemory.h"
 
#include <SimoxUtility/algorithm/string.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/util/StringHelpers.h>
 
#include "RobotAPI/libraries/armem/server/MemoryToIceAdapter.h"
#include "RobotAPI/libraries/armem_laser_scans/constants.h"
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/server/MemoryRemoteGui.h>
#include <RobotAPI/libraries/armem_laser_scans/aron/LaserScan.aron.generated.h>
 
#include <ArmarXCore/libraries/DecoupledSingleComponent/Decoupled.h>
 
ARMARX_REGISTER_COMPONENT_EXECUTABLE(armarx::armem::server::laser_scans::LaserScansMemory,
                                     "LaserScansMemory");
 
namespace armarx::armem::server::laser_scans
{
    LaserScansMemory::LaserScansMemory()
    {
        addPlugin(virtualRobotReaderPlugin);
        addPlugin(debugObserver);
    }
 
    armarx::PropertyDefinitionsPtr
    LaserScansMemory::createPropertyDefinitions()
    {
        armarx::PropertyDefinitionsPtr defs =
            new ComponentPropertyDefinitions(getConfigIdentifier());
 
        workingMemory().name() = "LaserScans";
 
        {
            const std::string prefix = "";
            commonVisu.defineProperties(defs, prefix + "visu.");
        }
 
        defs->optional(properties_.coreSeg.laserScans.maxHistorySize,
                       "LaserScans.CoreMaxHistorySize",
                       "Max history size of the " + QUOTED("LaserScans") + " core segment.");
 
        return defs;
    }
 
    std::string
    LaserScansMemory::getDefaultName() const
    {
        return "LaserScansMemory";
    }
 
    void
    LaserScansMemory::onInitComponent()
    {
        auto& coreSegment = workingMemory().addCoreSegment(
            "LaserScans", armarx::armem::laser_scans::arondto::LaserScanStamped::ToAronType());
 
        coreSegment.setMaxHistorySize(properties_.coreSeg.laserScans.maxHistorySize);
 
        commonVisu.init(&coreSegment, &virtualRobotReaderPlugin->get());
    }
 
    void
    LaserScansMemory::onConnectComponent()
    {
        commonVisu.connect(getArvizClient(), debugObserver->getDebugObserver());
        commonVisu.connectRemoteGui(this, "Laser Scanner Calibration");
        RemoteGui_startRunningTask();
    }
 
    void
    LaserScansMemory::RemoteGui_update()
    {
        commonVisu.remoteGuiUpdate();
    }
 
    void
    LaserScansMemory::onDisconnectComponent()
    {
        // Stop the visualization task before the core segment and the ArViz client go away.
        commonVisu.disconnect();
    }
 
    void
    LaserScansMemory::onExitComponent()
    {
    }
 
    armem::data::AddSegmentsResult
    LaserScansMemory::addSegments(const armem::data::AddSegmentsInput& input, const Ice::Current&)
    {
        // Allowing adding core segments.
        armem::data::AddSegmentsResult result =
            ReadWritePluginUser::addSegments(input, addCoreSegmentOnUsage);
 
        // Core segments created on usage do not inherit this component's history limit - they get
        // the library default of 120,000 snapshots per entity, which is ~1.5 GB per sensor frame at
        // laser-scan sizes. Apply the configured limit to them as well.
        if (addCoreSegmentOnUsage)
        {
            workingMemory().forEachCoreSegment(
                [this](armem::server::wm::CoreSegment& coreSegment)
                {
                    if (coreSegment.getMaxHistorySize() !=
                        properties_.coreSeg.laserScans.maxHistorySize)
                    {
                        coreSegment.setMaxHistorySize(
                            properties_.coreSeg.laserScans.maxHistorySize);
                    }
                });
        }
 
        return result;
    }
 
} // namespace armarx::armem::server::laser_scans