WorkingMemory.h

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/>.
*
* @package    MemoryX::ShortTermMemory
* @author     Kai Welke (welke at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/system/ImportExportComponent.h>
 
#include <MemoryX/interface/components/WorkingMemoryInterface.h>
#include <MemoryX/interface/memorytypes/MemorySegments.h>
#include <MemoryX/interface/workingmemory/AbstractWorkingMemoryInterface.h>
#include <MemoryX/libraries/workingmemory/AbstractWorkingMemory.h>
 
namespace memoryx
{
    class ObjectLocalizationMemoryUpdater;
    using ObjectLocalizationMemoryUpdaterPtr = IceInternal::Handle<ObjectLocalizationMemoryUpdater>;
 
    class WorkingMemoryPropertyDefinitions : public AbstractWorkingMemoryPropertyDefinitions
    {
    public:
        WorkingMemoryPropertyDefinitions(std::string prefix) :
            AbstractWorkingMemoryPropertyDefinitions(prefix)
        {
            defineOptionalProperty<bool>(
                "UseKalmanFilter", true, "Switch fusion with Kalman Filter on/off.");
 
            defineOptionalProperty<float>(
                "MatchThreshold",
                0.,
                "Threshold value of spatial proximity between observations \nto consider them "
                "belonging to the same instance (0..1)")
                .setMin(0)
                .setMax(1);
 
            defineOptionalProperty<bool>(
                "MatchByClassName",
                true,
                "Check for class equality when searching for corresponding instance");
        }
    };
 
    /*!
     * \brief The WorkingMemory class provides methods for storing runtime information. The data is stored in segments.
     *
     * On startup the working memory gets proxies of LongtermMemory, PriorKnowledge, CommonStorage
     * and creates a topic to publish updates
     * (established connections depend on the configuration, \see AbstractWorkingMemory).
     *
     * By default the WorkingMemory holds a segment to store object instances (e.g. recognized objects).
     * This segment is initialized with a fusion method which appends attributes from prior knowledge.
     * This means every time an entity is added, attribute enrichment (e.g. 3d model loading etc) is performed.
     * \see PriorAttributeEnrichmentFusion
     *
     * See \ref workingmemory "memoryx::WorkingMemory"    - abstract working memory, that gets updated "in the loop"
     */
    class ARMARXCOMPONENT_IMPORT_EXPORT WorkingMemory :
        virtual public AbstractWorkingMemory,
        virtual public WorkingMemoryInterface
    {
    public:
        // inherited from Component
        std::string
        getDefaultName() const override
        {
            return "WorkingMemory";
        }
 
        static std::string GetDefaultName();
 
        void onInitWorkingMemory() override;
        void onConnectWorkingMemory() override;
 
        void setUpdater(ObjectLocalizationMemoryUpdaterPtr locUpdater);
 
        /**
         * @see PropertyUser::createPropertyDefinitions()
         */
        armarx::PropertyDefinitionsPtr
        createPropertyDefinitions() override
        {
            return armarx::PropertyDefinitionsPtr(
                new WorkingMemoryPropertyDefinitions(getConfigIdentifier()));
        }
 
        /*!
         * \brief getObjectInstancesSegment Get the segment where all object instances are stored.
         *\see ObjectInstanceMemorySegment
         * \return The segment.
         */
        ObjectInstanceMemorySegmentBasePrx
        getObjectInstancesSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
 
        /*!
         * \brief getObjectClassesSegment Get the segment where all used object classes are stored.
         *\see ObjectClassMemorySegment
         * \return The segment.
         */
        ObjectClassMemorySegmentBasePrx
        getObjectClassesSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        RelationMemorySegmentBasePrx
        getRelationsSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
 
        ObjectLocalizationMemoryUpdaterBasePrx
        getObjectLocalizationUpdater(const ::Ice::Current& = Ice::emptyCurrent) override;
 
        CommonStorageInterfacePrx
        getCommonStorage(const ::Ice::Current& = Ice::emptyCurrent) const override;
        PriorKnowledgeInterfacePrx
        getPriorKnowledge(const ::Ice::Current& = Ice::emptyCurrent) const override;
        ActiveOacMemorySegmentBasePrx
        getActiveOacSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        AgentInstancesSegmentBasePrx
        getAgentInstancesSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        WorldStateSegmentBasePrx
        getWorldStateSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        virtual OacMemorySegmentBasePrx getOacSegment(const ::Ice::Current& = Ice::emptyCurrent);
        AffordanceSegmentBasePrx
        getAffordanceSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        EnvironmentalPrimitiveSegmentBasePrx
        getEnvironmentalPrimitiveSegment(const ::Ice::Current& = Ice::emptyCurrent) override;
        std::string getMemoryName(const Ice::Current&) const override;
 
    private:
        ObjectLocalizationMemoryUpdaterPtr locUpdater;
    };
 
    using WorkingMemoryPtr = IceInternal::Handle<WorkingMemory>;
 
} // namespace memoryx