EnvironmentalPrimitive.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::Core
* @author     Peter Kaiser <peter dot kaiser at kit dot edu>
* @date       2014
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/observers/variant/Variant.h>
 
#include <RobotAPI/libraries/core/Pose.h>
 
#include <MemoryX/core/entity/Entity.h>
#include <MemoryX/core/entity/EntityRef.h>
#include <MemoryX/interface/core/EntityBase.h>
#include <MemoryX/interface/memorytypes/MemoryEntities.h>
 
namespace memoryx::VariantType
{
    const armarx::VariantTypeId EnvironmentalPrimitive =
        armarx::Variant::addTypeName("::memoryx::EnvironmentalPrimitiveBase");
    const armarx::VariantTypeId PlanePrimitive =
        armarx::Variant::addTypeName("::memoryx::PlanePrimitiveBase");
    const armarx::VariantTypeId SpherePrimitive =
        armarx::Variant::addTypeName("::memoryx::SpherePrimitiveBase");
    const armarx::VariantTypeId CylinderPrimitive =
        armarx::Variant::addTypeName("::memoryx::CylinderPrimitiveBase");
    const armarx::VariantTypeId ConePrimitive =
        armarx::Variant::addTypeName("::memoryx::ConePrimitiveBase");
    const armarx::VariantTypeId BoxPrimitive =
        armarx::Variant::addTypeName("::memoryx::BoxPrimitiveBase");
    const armarx::VariantTypeId HigherSemanticStructure =
        armarx::Variant::addTypeName("::memoryx::HigherSemanticStructureBase");
} // namespace memoryx::VariantType
 
namespace memoryx
{
    class EnvironmentalPrimitive;
    using EnvironmentalPrimitivePtr = IceInternal::Handle<EnvironmentalPrimitive>;
 
    class EnvironmentalPrimitive : virtual public EnvironmentalPrimitiveBase, virtual public Entity
    {
    public:
        EnvironmentalPrimitive(const std::string& name = "",
                               const std::string& id = "",
                               const std::string& shape = "");
 
        std::string getShape(const Ice::Current& c = Ice::emptyCurrent) const override;
 
        armarx::Vector3BasePtr
        getOBBDimensions(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setOBBDimensions(const armarx::Vector3BasePtr& dimensions,
                              const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::FramedPoseBasePtr getPose(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setPose(const armarx::FramedPoseBasePtr& pose,
                     const Ice::Current& c = Ice::emptyCurrent) override;
 
        PointList getInliers(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setInliers(const PointList& inliers,
                        const Ice::Current& c = Ice::emptyCurrent) override;
 
        PointList getGraspPoints(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setGraspPoints(const PointList& graspPoints,
                            const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getProbability(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setProbability(float probability, const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getCircularityProbability(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setCircularityProbability(float probability,
                                       const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getLength(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setLength(float length, const Ice::Current& c = Ice::emptyCurrent) override;
 
        int getLabel(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setLabel(int label, const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::TimestampBasePtr getTime(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setTime(const armarx::TimestampBasePtr& time,
                     const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::MatrixFloatBasePtr
        getSampling(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setSampling(const armarx::MatrixFloatBasePtr& sampling,
                         const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        EnvironmentalPrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
 
    protected:
        void setShape(const std::string& shape, const Ice::Current& c = Ice::emptyCurrent) override;
    };
 
 
    class PlanePrimitive;
    using PlanePrimitivePtr = IceInternal::Handle<PlanePrimitive>;
 
    class PlanePrimitive : virtual public PlanePrimitiveBase, virtual public EnvironmentalPrimitive
    {
    public:
        PlanePrimitive(const std::string& name = "", const std::string& id = "");
        PlanePrimitive(std::vector<float>& coeffs);
 
        armarx::Vector3BasePtr
        getPlaneNormal(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setPlaneNormal(const armarx::Vector3BasePtr& normal,
                            const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getPlaneDistance(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setPlaneDistance(float distance, const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        PlanePrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
    class SpherePrimitive;
    using SpherePrimitivePtr = IceInternal::Handle<SpherePrimitive>;
 
    class SpherePrimitive :
        virtual public SpherePrimitiveBase,
        virtual public EnvironmentalPrimitive
    {
    public:
        SpherePrimitive(const std::string& name = "", const std::string& id = "");
        SpherePrimitive(std::vector<float>& coeffs);
 
        armarx::Vector3BasePtr
        getSphereCenter(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setSphereCenter(const armarx::Vector3BasePtr& center,
                             const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getSphereRadius(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setSphereRadius(float radius, const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        SpherePrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
    class CylinderPrimitive;
    using CylinderPrimitivePtr = IceInternal::Handle<CylinderPrimitive>;
 
    class CylinderPrimitive :
        virtual public CylinderPrimitiveBase,
        virtual public EnvironmentalPrimitive
    {
    public:
        CylinderPrimitive(const std::string& name = "", const std::string& id = "");
        CylinderPrimitive(std::vector<float>& coeffs);
 
        armarx::Vector3BasePtr
        getCylinderPoint(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setCylinderPoint(const armarx::Vector3BasePtr& point,
                              const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::Vector3BasePtr
        getCylinderAxisDirection(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setCylinderAxisDirection(const armarx::Vector3BasePtr& axis,
                                      const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getCylinderRadius(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setCylinderRadius(float radius, const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        CylinderPrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
 
    class ConePrimitive;
    using ConePrimitivePtr = IceInternal::Handle<ConePrimitive>;
 
    class ConePrimitive : virtual public ConePrimitiveBase, virtual public EnvironmentalPrimitive
    {
 
    public:
        ConePrimitive(const std::string& name = "", const std::string& id = "");
        ConePrimitive(std::vector<float>& coeffs);
 
        armarx::Vector3BasePtr
        getConeApex(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setConeApex(const armarx::Vector3BasePtr& apex,
                         const Ice::Current& c = Ice::emptyCurrent) override;
 
        armarx::Vector3BasePtr
        getConeAxisDirection(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setConeAxisDirection(const armarx::Vector3BasePtr& axis,
                                  const Ice::Current& c = Ice::emptyCurrent) override;
 
        float getConeOpeningAngle(const Ice::Current&) const override;
        void setConeOpeningAngle(float angle, const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        ConePrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
 
    class BoxPrimitive;
    using BoxPrimitivePtr = IceInternal::Handle<BoxPrimitive>;
 
    class BoxPrimitive : virtual public BoxPrimitiveBase, virtual public EnvironmentalPrimitive
    {
 
    public:
        BoxPrimitive(const std::string& name = "", const std::string& id = "");
 
        EntityRefList getBoxSides(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setBoxSides(const EntityRefList& sides,
                         const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        BoxPrimitivePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
 
    class HigherSemanticStructure;
    using HigherSemanticStructurePtr = IceInternal::Handle<HigherSemanticStructure>;
 
    class HigherSemanticStructure :
        virtual public HigherSemanticStructureBase,
        virtual public EnvironmentalPrimitive
    {
 
    public:
        HigherSemanticStructure(const std::string& name = "", const std::string& id = "");
 
        EntityRefList getPrimitives(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setPrimitives(const EntityRefList& primitives,
                           const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::StringSeq getLabels(const Ice::Current& c = Ice::emptyCurrent) const override;
        void setLabels(const Ice::StringSeq& labels,
                       const Ice::Current& c = Ice::emptyCurrent) override;
 
        Ice::ObjectPtr ice_clone() const override;
        HigherSemanticStructurePtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
    };
 
 
} // namespace memoryx