CscKnowledgeItemTargetMemberToState.h

Go to the documentation of this file.

/*
 * CscKnowledgeStanding.h
 *
 *  Created on: 31 mai 2014
 *      Author: ilieszaoui
 */
 
#ifndef CscKnowledgeItemTargetMemberToState_H_
#define CscKnowledgeItemTargetMemberToState_H_
 
#include "ArtificialIntelligence/CscStrategyType.h"
#include "Knowledge/CscKnowledgeItemTarget.h"
#include "ArtificialIntelligence/CscJacobianInverseKinematic.h"
#include <random>
 
namespace conscience_core::knowledge {
 
    class CSC_DLL_IMPORTEXPORT CscKnowledgeItemTargetMemberToState : public CscKnowledgeItemTarget {
    public:
        CscKnowledgeItemTargetMemberToState(int knoItemIdIn, string knoItemNameIn, const vector<const TargetMemberValues *> *inputsTargetValuesIn, const vector<const TargetMemberPonderation *> *inputsTargetPercentsIn, map<string, float> *outputsCanMoveValues, CscUnitType unitTypeIn, string targetOriginMember, bool symemtrySearch, int nbStateMax, const map<int, float> &maxDeltaPivotByPivotId, bool optionCutLastestIfTheSameAndWorst, bool optionCutBeginingIfTheSame, bool optionDeltaPerStateMaxDegressive, float percentAvg, float percentMax, float percentExtrapolation, int stateDuration, int stateDelay, float solvedAt, float processedAt, bool outputTypes[], CscArtificialIntelligenceTypes aiTypes, map<int, CscPoint3d*> centerOfMassOfAllMemberByMemberId);
 
        void sequencePostTraitment(CscSequence *sequenceIn) override;
        int getSequenceCountAutorized(float initStateValue) override;
        float getExtrapolationResult(CscSequence *sequenceIn) override;
        bool isStatesSupportOf(CscState *state1, CscState *state2) override;
        bool isObjectiveSupportOf(CscKnowledgeItem *knowledgeItem) override;
        float evaluateState(CscState *stateIn, const CscWorldEntity *entity, CscState *initialState) override;
        virtual ~CscKnowledgeItemTargetMemberToState();
        
        CscPerson *generatePerson(CscEnvironmentSimulator *environment, const CscWorldEntity *entity, CscState *initialState, int personId, int generationId, CscGeneration *currentGeneration, CscGeneration *previousGeneration) override;
 
        int getActionmaxJointDelta(float initStateValue);
        map<CscStrategyType, float> strategyElitism;
        map<CscStrategyType, float> strategyProbability;
 
        static CscKnowledgeItemTargetMemberToState *create(int targetId, string targetName,
                                                           vector<string> targetMemberNames,
                                                           vector<string> relativeToMemberNames,
                                                           vector<float> posX, vector<float> posY, vector<float> posZ,
                                                           vector<float> posPondX, vector<float> posPondY, vector<float> posPondZ,
                                                           vector<float> pitch, vector<float> yaw, vector<float> roll,
                                                           vector<float> pitchPond, vector<float> yawPond, vector<float> rollPond,
                                                           vector<float> accX, vector<float> accY, vector<float> accZ,
                                                           vector<float> accPondX, vector<float> accPondY, vector<float> accPondZ,
                                                           vector<string> outputsCanMoveNames, vector<float> outputsCanMovePonderations,
                                                           CscUnitType unitType, string targetOriginMember,
                                                           bool symemtrySearch,
                                                           int nbStateMax, const map<int, float> &maxDeltaPivotByPivotId,
                                                           bool optionCutLastestIfTheSameAndWorst,
                                                           bool optionCutBeginingIfTheSame,
                                                           bool optionDeltaPerStateMaxDegressive,
                                                           float percentAvg,
                                                           float percentMax,
                                                           float percentExtrapolation,
                                                           int stateDuration,
                                                           int stateDelay,
                                                           float solvedAt,
                                                           float processedAt,
                                                           bool outputTypes[],
                                                           CscArtificialIntelligenceTypes aiTypes,
                                                           map<int, CscPoint3d*> centerOfMassOfAllMemberByMemberId) {
 
            vector<const TargetMemberValues *> *targetMembersValues = new vector<const TargetMemberValues *>();
            vector<const TargetMemberPonderation *> *inputsTargetPercents = new vector<const TargetMemberPonderation *>();
 
            // State objective
            for (int i = 0; i < targetMemberNames.size(); i++) {
                TargetMemberValues *targetMemberVal = new TargetMemberValues();
                CscMemberInputStatus *inputsFinalCore = new CscMemberInputStatus(targetMemberNames.at(i));
                map<CscInputType, float> inputsTargetValuesCore;
                inputsTargetValuesCore[POS_X] = posX.at(i);
                inputsTargetValuesCore[POS_Y] = posY.at(i);
                inputsTargetValuesCore[POS_Z] = posZ.at(i);
                inputsTargetValuesCore[PITCH] = pitch.at(i);
                inputsTargetValuesCore[YAW] = yaw.at(i);
                inputsTargetValuesCore[ROLL] = roll.at(i);
                inputsTargetValuesCore[ACC_X] = accX.at(i);
                inputsTargetValuesCore[ACC_Y] = accY.at(i);
                inputsTargetValuesCore[ACC_Z] = accZ.at(i);
                inputsFinalCore->values = inputsTargetValuesCore;
                targetMemberVal->memberValues = inputsFinalCore;
                targetMemberVal->relativeToMemberName = relativeToMemberNames.at(i);
                targetMembersValues->push_back(targetMemberVal);
            }
 
            // State Percents
            for (int i = 0; i < targetMemberNames.size(); i++) {
                TargetMemberPonderation *targetMemberPonderation = new TargetMemberPonderation();
                CscMemberInputPonderation *percentsFInalCore = new CscMemberInputPonderation(targetMemberNames.at(i));
                map<CscInputType, float> inputsTargetPercentsCore;
                inputsTargetPercentsCore[POS_X] = posPondX.at(i);
                inputsTargetPercentsCore[POS_Y] = posPondY.at(i);
                inputsTargetPercentsCore[POS_Z] = posPondZ.at(i);
                inputsTargetPercentsCore[PITCH] = pitchPond.at(i);
                inputsTargetPercentsCore[YAW] = yawPond.at(i);
                inputsTargetPercentsCore[ROLL] = rollPond.at(i);
                inputsTargetPercentsCore[ACC_X] = accPondX.at(i);
                inputsTargetPercentsCore[ACC_Y] = accPondY.at(i);
                inputsTargetPercentsCore[ACC_Z] = accPondZ.at(i);
                percentsFInalCore->values = inputsTargetPercentsCore;
                targetMemberPonderation->memberValues = percentsFInalCore;
                targetMemberPonderation->relativeToMemberName = relativeToMemberNames.at(i);
                inputsTargetPercents->push_back(targetMemberPonderation);
            }
 
            // OutputsCanMove
            map<string, float> *outputsCanMoveValues = new map<string, float>;
            for (int i = 0; i < outputsCanMoveNames.size(); i++) {
                if (outputsCanMovePonderations.at(i) > 0.0f) {
                    string name = outputsCanMoveNames.at(i);
                    float ponderation = outputsCanMovePonderations.at(i);
                    outputsCanMoveValues->insert({name, ponderation});
                }
            }
 
            return new CscKnowledgeItemTargetMemberToState(targetId, targetName, targetMembersValues, inputsTargetPercents, outputsCanMoveValues, unitType, targetOriginMember, symemtrySearch, nbStateMax, maxDeltaPivotByPivotId, optionCutLastestIfTheSameAndWorst, optionCutBeginingIfTheSame, optionDeltaPerStateMaxDegressive, percentAvg, percentMax, percentExtrapolation, stateDuration, stateDelay, solvedAt, processedAt, outputTypes, aiTypes, centerOfMassOfAllMemberByMemberId);
        }
        
        int findBestStateIndex(CscSequence *parentSequence);
        
        struct CSC_DLL_IMPORTEXPORT InverseKinematicParams {
            public :
            float loweringPelvis;
            float footElevation;
            float lateralMove;
            float stepSize;
            float objectiveValue;
            
            InverseKinematicParams(float loweringPelvis, float footElevation, float lateralMove, float stepSize) :
            loweringPelvis(loweringPelvis),
            footElevation(footElevation),
            lateralMove(lateralMove),
            stepSize(stepSize),
            objectiveValue(0.0f) {
            }
        };
        
        vector<InverseKinematicParams> allParams;
 
    private:
        map<int, CscPoint3d*> centerOfMassOfAllMemberByMemberId;
        
        map<int, float> lotteryWheelCreation(CscGeneration *previousGeneration);
        
        CscSequence *drawLotteryWheel(CscGeneration *previousGeneration, map<int, float> lotteryWheel, float totalScoreGeneration, int previousGenerationSize, vector<CscPerson *> *parents);
        
        CscSequence *drawOneParentLotteryWheel(CscGeneration *previousGeneration, vector<CscPerson *> *parents, map<int, float> lotteryWheel);
 
        CscSequence *selectOneParentByTournament(CscState *initialState, CscGeneration *previousGeneration, unsigned nbParticipants, float probaForBest, vector<CscPerson *> *parents, const CscEntityModel *entityModel, optional<int> nbStateAdded = {});
 
        CscSequence *crossover(CscSequence *firstParentSequence, CscSequence *secondParentSequence, int indexCrossing, CscSequence *sequence, const CscEntityModel *entity);
        
        CscSequence *horizontalCrossover(CscSequence *firstParentSequence, CscSequence *secondParentSequence, const CscEntityModel *entityModel, CscState *initialState);
        
        CscSequence *rightLeftCrossover(CscSequence *firstParent, CscSequence *secondParent, const CscEntityModel *entity);
        
        float randomInterpolationValue(float previousValue, float nextValue, float minValue, float maxValue);
        CscState *mutationState(const CscEntityModel *robotModel, CscState *previousState, CscState *nextState, bool symmetry);
        
        CscSequence *symetryRightLeftMutation(CscSequence *initSequence, const CscEntityModel *entityModel);
        
        bool findBestParent(vector<CscPerson *> *parents);
        
        CscSequence *randomCompleteSequence(CscSequence *initSequence, const CscEntityModel *entityModel, optional<int> nbStateAdded = {}, bool sameProgressionRightLeft = false);
        
        CscSequence *randomStrategy(const CscEntityModel *entityModel, CscState *initialState);
        
        /*
         Return state’s id before first drop in objective value of a certain value.
         * dropTolerance sets this value
         If nothing exceeds the dropTolerance then we return the index before biggest drop in objective value
         */
        int findIdOfStateBeforeFirstDropObjectiveValue(CscSequence *sequence, float dropTolerance);
        
        CscStrategyType randomlyDrawStrategyType(const CscEntityModel *entityModel) const;
        
        /*
         Creates a complete sequence from the initial state with InverseKinematic.
         */
        CscSequence *inverseKinematic(const CscWorldEntity *entity, CscState *initialState, vector<vector<CscJacobianInverseKinematic::TargetIKParams*>> targetsForAllState, CscEnvironmentSimulator *environment);
        
        void modifyIKTargetWithRegression(optional<vector<vector<CscJacobianInverseKinematic::TargetIKParams*>>> targetsInverseKinematic, const vector<vector<float>> &data);
        
        void duplicateStepForWalk(const CscWorldEntity *entity, CscSequence *sequenceToModify);
        
    public:
        tuple<CscSequence*, vector<CscPerson *>*> createPersonWithChosenStrategy(CscStrategyType strategy, const CscWorldEntity *entity, CscState *initialState,  CscGeneration *previousGeneration, CscEnvironmentSimulator *environment, optional<vector<vector<CscJacobianInverseKinematic::TargetIKParams*>>> targetsInverseKinematic);
    };
 
}
 
#endif /* CscKnowledgeItemTargetGenetic_H_ */