source: cpp/frams/genetics/fL/fL_general.h @ 785

#ifndef _FL_GENERAL_

#define _FL_GENERAL_

#include <frams/util/sstring.h>
#include <frams/param/mutableparam.h>
#include <frams/param/paramobj.h>
#include <vector>
#include <list>
#include <unordered_map>
#include <frams/model/model.h>
#include "fL_matheval.h"

/// determines to which class fL element belongs
enum fLElementType {
        TERM, ///< word of L-System
        INFO, ///< fL_Builder object
        RULE, ///< rule of L-System
        BRANCH ///< special type of fL word, which represents branch
};

/** @name Constants used in fL methods */
//@{
#define PART_PROPS_COUNT   4 ///<Count of part properties
#define JOINT_PROPS_COUNT  3 ///<Count of joint properties
#define PE_NEURO_DET       "d" ///<Id of details type definition in f0_neuro_paramtab
#define PE_CONN_WEIGHT     "w" ///<Id of weight type definition in f0_neuroconn_paramtab
//@}

extern const char *fL_part_names[];
extern const char *fL_joint_names[];
extern const char *fL_joint_fullnames[JOINT_PROPS_COUNT];
extern const char *fL_part_fullnames[PART_PROPS_COUNT];

#define LSYSTEM_PARAM_TYPE "s" ///< standard type of L-System elements

class fL_Builder;

/**
 * Most abstract class of L-System. It requires from inheriting classes to implement
 * methods processDefinition and toString.
 */
class fL_Element
{
public:
        fLElementType type; ///< type of fL_Element

        fL_Element(fLElementType type) : type(type) {}
        virtual ~fL_Element() { }

        /**
         * Performs connecting current element to fL_Builder and parsing of input
         * with respect of builder.
         * @param builder fL_Builder object responsible for creating this element
         * @return 0 if processing went successfully, other values otherwise
         */
        virtual int processDefinition(fL_Builder *builder) = 0;

        /**
         * Creates string line for current element. This method is used by Builder
         * to create string representation of words, rules and informations of L-System.
         * @return stringified element
         */
        virtual SString toString() = 0;
};

/**
 * Represents word objects of L-System representation. They are used in axiom,
 * produced sequences and rules.
 */
class fL_Word : public fL_Element
{
public:
        SString name; ///<name of word
        int npar; ///<number of word parameters
        MutableParam mut; ///<MutableParam for word parameters
        ParamEntry *tab; ///<ParamTab used for loading and saving properties of word
        void *data; ///<pointer to properties of word
        bool builtin; ///<determines if word is built-in (true) or not (false).
        std::vector<MathEvaluation *> parevals; ///<stores MathEvaluation objects with parameter functions
        double creationiter; ///<this helper field is used during L-System iterations and determines when word was created
        fL_Word(bool builtin = false) :
                fL_Element(fLElementType::TERM), mut("Word", "Properties"), //TODO change Word to Term everywhere
                builtin(builtin)
        {
                name = "";
                npar = 0;
                tab = NULL;
                data = NULL;
                creationiter = 0;
        }

        /**
         * Destroys data ParamObject and MathEvaluation objects. ParamTab for Word
         * should be deleted separately, because all words with same name share same
         * pointer to ParamTab.
         */
        ~fL_Word()
        {
                if (data)
                        ParamObject::freeObject(data);
                for (MathEvaluation *ev : parevals)
                {
                        delete ev;
                }
                parevals.clear();
        }

        /**
         * Checks if there is no other word stored in the builder with the same name,
         * prepares ParamTab for defined word and adds created word definition to the
         * builder.
         * @param builder pointer to the builder that process this word definition
         * @return 0 if word is added, 1 if word is redefined
         */
        int processDefinition(fL_Builder *builder);

        /**
         * Operator copies name string, npar value, pointer to ParamTab and pointers
         * to MathEvaluation objects for parameters. It sets data of this word to
         * NULL.
         * @param src source word
         */
        void operator=(const fL_Word& src);

        /**
         * TODO
         */
        bool operator==(const fL_Word& other) const;

        /**
         * Returns 'w:' line defining word in genotype.
         * @return string representation of word definition
         */
        virtual SString toString();

        /**
         * Returns token version of this word. It is used during converting successor's
         * list or axiom list into strings. Flag 'keepformulas' should be set to true
         * if word parameters should be represented as formulas, and set to false if
         * word parameters should contain the result of evaluation.
         * @param keepformulas true if parameters should have mathematical formula, false if it should have result of evaluation
         */
        virtual SString stringify(bool keepformulas = true);

        /**
         * Saves formulas or evaluations of parameters in ParamObject.
         * @param keepformulas true if parameters should have mathematical formula, false if it should have result of evaluation
         * @return 0 if method successfully managed to save data, 1 if an error occured
         */
        int saveEvals(bool keepformulas);
};

/**
 * Represents special branching word in L-System genotype.
 */
class fL_Branch : public fL_Word
{
public:
        /// Determines if branching parenthesis is opened or closed
        enum BranchType {
                OPEN,
                CLOSE
        };
        BranchType btype; ///< branch parenthesis type
        fL_Branch(BranchType branchtype) : fL_Word()
        {
                type = fLElementType::BRANCH;
                btype = branchtype;
                name = stringify();
        }
        SString toString() { return ""; };
        SString stringify(bool keepformulas = false) { return btype == BranchType::OPEN ? "[" : "]"; }
};

/**
 * Represents rules in L-System genotype. Every rule has predecessor and successors.
 * The optional argument is a condition of deploying rule. Every rule is ran
 * synchronously for every letter of the current genotype. If condition and
 * predecessor are satisfied, then predecessor is replaced by successors.
 */
class fL_Rule : public fL_Element
{
public:
        SString predecessor; ///<string representation of the predecessor
        SString condition; ///<string representation of the condition
        SString successor; ///<string representation of the successor

        fL_Word *objpred; ///<object representation of the predecessor
        MathEvaluation *condeval; ///<object representation of the condition

        std::list<fL_Word *> objsucc; ///<objec representation of successors

        int start; ///<beginning of the rule definition in genotype
        int end; ///<end of the rule definition in genotype

        fL_Rule(int start, int end) : fL_Element(fLElementType::RULE),
                start(start), end(end)
        {
                predecessor = "";
                condition = "";
                successor = "";
                objpred = NULL;
                condeval = NULL;
        }

        ~fL_Rule()
        {
                if (objpred) delete objpred;
                if (condeval) delete condeval;
                for (fL_Word *word : objsucc)
                {
                        delete word;
                }
                objsucc.clear();
        }

        /**
         * Loads rule definition from the genotype, checks if word defined in
         * predecessor does exist, tokenizes successor and condition.
         * @param builder pointer to the builder that process this word definition
         * @return 0 if word is added, 1 if an error occured during parsing
         */
        int processDefinition(fL_Builder *builder);

        SString toString();

        /**
         * Runs rule for a given word, if all conditions and starting rules are satisfied.
         * Method alters given list of tokens by removing matching word pointed by
         * pointer and iterator of list and inserting successor sequence into list.
         * Final iterator value points to the first word after processed word.
         * @param in word that is currently processed
         * @param it iterator of genotype list which determines position of current analysis
         * @param genotype current genotype. Words on the left of genotype are processed and possibly replaced by previous rules
         * @param currtime value representing continuous time value for rule
         * @return 0 if rule processed current word, 1 if rule is no applicable
         */
        int deploy(fL_Word *in, std::list<fL_Word *>::iterator &it, std::list<fL_Word *> &genotype, double currtime);
};

struct fL_State
{
        Pt3D direction; ///<Direction of turtle
        Part *currpart; ///<Latest created part
        Neuro *currneuron; ///<Latest created neuron
        fL_State() : direction(1, 0, 0), currpart(NULL), currneuron(NULL)
        { }
};

/**
 * Main class of L-System processing. It holds all information required to perform
 * steps of development of a creature. It allows to create Timed D0L-Systems with
 * following limitations:
 *
 *  - fractions of time affect only parameters of currently produced words,
 *  - integer steps deploy rules in order to develop new elements of body,
 *  - if parameter should use time fraction, then $t variable must be used,
 *  - $t variable always contain values from 0 to 1 that represent current fraction
 *    of step.
 */
class fL_Builder : public fL_Element
{
public:
        SString axiom; ///<starting sequence of genotype
        double time; ///<time of creature development
        int numckp; ///<number of checkpoints per growth step - checkpoints are always created after rules deployment in integer steps, numckp determines how many checkpoints should be created within single step (to watch changes of parameters)

        std::list<fL_Word *> genotype; ///<list of current words of genotype
        std::unordered_map<std::string, fL_Word *> words; ///<map from string to words existing in L-System
        std::vector<fL_Rule *> rules; ///<rules available in system

        fL_Builder() : fL_Element(fLElementType::INFO)
        {
                axiom = "";
                time = 1.0;
                numckp = 1;
        }
        ~fL_Builder();

        /**
         * Helper function for trimming leading and trailing spaces from sequence.
         * @param data input string
         * @return string with trimmed spaces
         */
        static std::string trimSpaces(std::string data);

        /**
         * Processes single line of input sequence and load line properties with use
         * of proper ParamTab.
         * @param type which type of line is this
         * @param line line to be processed
         * @param obj variable storing pointer to created L-System element
         * @param linenumber for error messages
         * @param begin index of first character of line
         * @param end index of last character of line
         * @return 0 if processing ended successfully, 1-based position of error otherwise
         */
        int processLine(fLElementType type, SString line, fL_Element *&obj, int linenumber, int begin, int end);

        /**
         * Parses input genotype with words, information and rules. First of all,
         * model-specific words defined in addModelWords method are added to words map.
         * Every genotype should start with words definitions. They cannot collide
         * with model words and with each other. Secondly, information line, containing
         * axiom and number of iteration must be processed. In the end, all rules
         * have to be processed by builder. After determining line type and creating
         * fL_Element specialized object, the builder runs object's processDefinition
         * method to generate all important objects and register element in builder
         * structures.
         * @param genotype input genotype
         * @return 0 if processing finished successfully, 1-based position of error if it occured
         */
        int parseGenotype(SString genotype);

        /**
         * Prepares structures and tokenizes axiom.
         * @param builder this method should receive pointer to itself
         * @return 0 if processing went successfully, 1 otherwise
         */
        int processDefinition(fL_Builder *builder);

        /**
         * Adds words used for Framsticks body and brain development.
         */
        void addModelWords();

        /**
         * Helper method that tokenizes string sequence by closing parenthesis
         * with respect to parenthesis nesting.
         * @param pos index of character, from which next token needs to be extracted. Method replaces this parameter with next starting position, or -1 if there was an error during parsing, like parenthesis mismatch
         * @param src original sequence
         * @param token reference to variable holding new token
         * @return true if new token is found, false if there is no more tokens or when there was parenthesis mismatch (if pos == -1, then it is parenthesis mismatch)
         */
        bool getNextObject(int &pos, SString src, SString &token);

        /**
         * Helper function that converts input sequence into list of L-System words.
         * @param sequence input sequence of stringified word objects
         * @param result reference to list holding generated words
         * @param numparams number of parameters that can be used for words stored in result list
         * @return 0 if tokenizing finished successfully, 1 otherwise
         */
        int tokenize(SString sequence, std::list<fL_Word *> &result, int numparams);

        /**
         * Uses rules to process current genotype and make next iteration step for
         * L-System development.
         * @param currtime current time of genotype processing
         * @return always 0
         */
        int iterate(double currtime);

        /**
         * Alters only parameters that depend on time. Should be used if only fraction
         * of iteration has changed, not integer part.
         * @param currtime current time of processing
         * @return always 0
         */
        int alterTimedProperties(double currtime);

        /**
         * Developes L-System from given genotype and builds Framsticks Model from it.
         */
        int develop();

        /**
         * Creates new checkpoint for a given model based on current state of genotype.
         * @param model reference to model
         * @return 0 if developing went successfully, 1 otherwise
         */
        int developModel(Model &model);

        /**
         * Returns stringified product of L-System development.
         * @return stringified words of developed L-System
         */
        SString getStringifiedProducts();

        /**
         * Returns genotype stored by objects in fL_Builder.
         * @return genotype converted from L-System objects
         */
        SString toString();

        /**
         * TODO
         */
        int alterPartProperties(Part *part, fL_Word *stickword, double &alterationcount);

        /**
         * TODO
         */
        Neuro *findInputNeuron(std::list<fL_Word *> genotype, std::list<fL_Word *>::iterator it, fL_Word *attractor);

        /**
         * TODO
         */
        void findNext(fL_Word *word, std::list<fL_Word *> genotype, std::list<fL_Word *>::iterator &it);
};

#endif // _FL_GENERAL_