CscKnowledgeItem.h

Go to the documentation of this file.

//
//  CscKnowledgeItem.hpp
//  ConscienceRobotManager
//
//  Created by ILIES ZAOUI on 05/06/2018.
//  Copyright © 2018 IliesZaoui. All rights reserved.
//
 
#ifndef CscKnowledgeItem_h
#define CscKnowledgeItem_h
 
#include "CoreObjects/CscEntityModel.h"
#include "CoreObjects/CscMemberInputPonderation.h"
#include "CoreObjects/CscSequence.h"
#include "CoreObjects/CscState.h"
#include "CoreObjects/CscWorldEntity.h"
#include "CscCommon.h"
#include "Knowledge/CscKnowledgeItemType.h"
#include "Unit/CscUnitOrigin.h"
#include "Unit/CscUnitType.h"
#include <limits>
 
using std::vector, std::string, std::numeric_limits;
 
namespace conscience_core::knowledge {
 
    enum CscArtificialIntelligenceType : uint64_t {
        NONE = 0,
        GENETIC = 1 << 0,
        INVERSE_KINEMATIC = 1 << 1,
        INVERSE_KINEMATIC_JACOBIAN = 1 << 2
    };
    typedef uint64_t CscArtificialIntelligenceTypes;
 
    inline bool hasAIType(CscArtificialIntelligenceTypes types, CscArtificialIntelligenceType requestedType) {
        return (types & requestedType) == requestedType;
    }
 
    class CSC_DLL_IMPORTEXPORT CscKnowledgeItem {
    protected:
        void cutBeginingIfTheSame(CscSequence *sequenceIn, float maxIn);
        void cutBeginingIfSupport(CscSequence *sequenceIn);
        void cutLastestIfTheSameAndWorst(CscSequence *sequenceIn, float maxIn);
        void cutInternalSubSequencesIfCommonState(CscSequence *sequenceIn);
        
        bool usePivots() const;
        bool usePropellers() const;
        bool useWheels() const;
        bool useTranslations() const;
 
    public:
        int knowledgeItemId;
        string knowledgeItemName;
 
        CscKnowledgeItem(int knoItemId, string knoItemName, CscArtificialIntelligenceTypes aiTypes = CscArtificialIntelligenceType::NONE, bool outputTypes[] = NULL);
 
        CscKnowledgeItemType knowledgeType;
        void applyWheels(CscSequence *result, vector<string> *names);
        void applyWheels(CscState *result, vector<string> *names);
 
        void applyJoints(CscState *result, vector<string> *names);
        void applyJoints(CscSequence *result, vector<string> *names);
 
        virtual float evaluateSequence(CscSequence *sequence, const CscWorldEntity *entity, CscState *initialStateInit);
        virtual float evaluateState(CscState *state, const CscWorldEntity *entity, CscState *initialState);
        int maxSequenceSize = 100;
        float maxJointDelta = 100.0;
        float maxWheelsDelta = 100.0f;
        float maxPropellersDelta = 100.0f;
        float maxTranslationsDelta = 100.0f;
        map<int, float> maxPivotDeltaByPivotId;
        bool symetricMovments = true;
 
        struct CSC_DLL_IMPORTEXPORT TargetMemberValues {
            CscMemberInputStatus *memberValues;
            optional<string> relativeToMemberName;
        };
 
        struct CSC_DLL_IMPORTEXPORT TargetMemberPonderation {
            CscMemberInputPonderation *memberValues;
            optional<string> relativeToMemberName;
        };
        
        struct CSC_DLL_IMPORTEXPORT LimitsPivot {
        private:
            int pivotId;
            float limitMin;
            float limitMax;
        public:
            LimitsPivot(int pivotId, float limitMin, float limitMax) : pivotId(pivotId), limitMin(limitMin), limitMax(limitMax) {
            }
            int getPivotId() const {
                return pivotId;
            }
            float getLimitMin() const {
                return limitMin;
            }
            float getLimitMax() const {
                return limitMax;
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT LimitsPropeller {
        private:
            int propellerId;
            float limitSpeed;
        public:
            LimitsPropeller(int propellerId, float limitSpeed) : propellerId(propellerId), limitSpeed(limitSpeed) {
            }
            int getPropellerId() const {
                return propellerId;
            }
            float getLimitSpeed() const {
                return limitSpeed;
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT LimitsWheel {
        private:
            int wheelId;
            float limitSpeed;
        public:
            LimitsWheel(int wheelId, float limitSpeed) : wheelId(wheelId), limitSpeed(limitSpeed) {
            }
            int getWheelId() const {
                return wheelId;
            }
            float getLimitSpeed() const {
                return limitSpeed;
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT LimitsTranslation {
        private:
            int translationId;
            float limitSpeed;
            float limitMin;
            float limitMax;
        public:
            LimitsTranslation(int translationId, float limitSpeed, float limitMin, float limitMax) : translationId(translationId), limitSpeed(limitSpeed), limitMin(limitMin), limitMax(limitMax) {
            }
            int getTranslationId() const {
                return translationId;
            }
            float getLimitSpeed() const {
                return limitSpeed;
            }
            float getLimitMin() const {
                return limitMin;
            }
            float getLimitMax() const {
                return limitMax;
            }
        };
        
        const map<string, float> *outputsCanMoveValues = new map<string, float>;
        
        const map<string, float> getOutputsCanMoveValues() const;
        vector<const LimitsPivot*> getPivotsCanMoveValues() const;
        vector<const LimitsPropeller*> getPropellersCanMoveValues() const;
        vector<const LimitsWheel*> getWheelsCanMoveValues() const;
        vector<const LimitsTranslation*> getTranslationsCanMoveValues() const;
        
        void setPivotsCanMoveValues(const LimitsPivot *limitsPivot);
        void setPropellersCanMoveValues(const LimitsPropeller *limitsPropeller);
        void setWheelsCanMoveValues(const LimitsWheel *limitsWheel);
        void setTranslationsCanMoveValues(const LimitsTranslation *limitsTranslation);
 
        const vector<const TargetMemberValues *> *inputsTargetValues = new vector<const TargetMemberValues *>();
        const vector<const TargetMemberPonderation *> *inputsTargetPercents = new vector<const TargetMemberPonderation *>();
 
        float sequencePercentMax = 1.0;
        float sequencePercentAvg = 0.0;
        float sequencePercentCountStates = 0.0;
        float sequencePercentExtrapolation = 0.0;
        float sequencePercentAccEnd = 0.0;
 
        bool optionCutLastestIfTheSameAndWorst = false;
        bool optionCutBeginingIfTheSame = false;
        bool optionDeltaPerStateMaxDegressive = false;
        bool strictPonderations = false;
 
        float solvedAt = 1.0;
        float processAt = 1.0;
 
        virtual bool isStatesSupportOf(CscState *state1, CscState *state2);
        virtual bool isObjectiveSupportOf(CscKnowledgeItem *knowledgeItem);
 
        float isSupportActionDiff = 5.0;
        float isSupportHeightDiff = 10;
        float isSupportAccDiff = 0.3;
        float isSupportGyroDiff = 10.0;
 
        bool deploymentWhenAnotherIsSolved = false;
        bool deploymentInitialGlobal = false;
        bool selfDeploymentAnticipation = false;
        bool antiKinematic = false;
 
        virtual int getActionDeltaAutorized(float initStateValue);
        virtual int getSequenceCountAutorized(float initStateValue);
        virtual float getExtrapolationResult(CscSequence *sequenceIn);
 
        virtual void sequencePostTraitment(CscSequence *sequanceIn);
        virtual ~CscKnowledgeItem();
 
        int getDistance(int angle1, int angle2);
 
        string toString();
        /*
         Create a state randomly from the previous state respecting the maxDeltas.
         * symmetry will make the symmetric pivots (left and right) have the same value.
         * sameProgressionRightLeft will make 2 symmetric pivots have the same difference between the previous state and the state being generated
         */
        virtual CscState *generateRandomStateFromState(const CscEntityModel *robotModel, CscState *currentState, bool symmetry, bool sameProgressionRightLeft = false);
        bool outputTypes[4];
        const CscArtificialIntelligenceTypes aiTypes;
 
        static unsigned long long nextId() {
            if (lastId >= numeric_limits<unsigned long long>::max() - 2) {
                LOG_ERROR("FATAL : Csc knowledge item counter reached max - there might be a problem");
                exit(1);
            }
            return ++lastId;
        }
        
        /*
         Modify initStateObjectiveValue which indicate the initial state’s objective value
         */
        void setInitStateObjectiveValue(float value);
        /*
         Got initStateObjectiveValue which indicate the initial state’s objective value
         */
        float getInitStateObjectiveValue() const;
        
        /*
         Determine if all playSequence in physicsSimulator must be played in realTime.
         By default it return false.
         */
        virtual bool shouldAlwaysPlayInRealTime() const;
        
        virtual map<int, CscPivotMovementType> createPivotMovementTypeByPivotId(const CscEntityModel *robotModel);
        
        virtual map<int, CscPivotMovementType> getPivotMovementTypeByPivotId(const CscEntityModel *robotModel);
    protected :
        /*
         Add extrapolation states that allow to check if the sequence is realy correct.
         */
        virtual void addExtrapolationStates(CscSequence *sequenceIn, const CscWorldEntity *entity);
        
        map<int, CscPivotMovementType> pivotMovementTypeByPivotId;
        
    private:
        inline static unsigned long long lastId = 0;
        
        /*
         Indicate the initial state’s objective value
         */
        float initStateObjectiveValue = 0.0;
        
        vector<const LimitsPivot*> *pivotsCanMoveValues = new vector<const LimitsPivot*>;
        vector<const LimitsPropeller*> *propellersCanMoveValues = new vector<const LimitsPropeller*>;
        vector<const LimitsWheel*> *wheelsCanMoveValues = new vector<const LimitsWheel*>;
        vector<const LimitsTranslation*> *translationsCanMoveValues = new vector<const LimitsTranslation*>;
        
    };
 
}
 
#endif /* CscKnowledgeItem_hpp */