source: cpp/frams/genetics/f1/conv_f1.cpp @ 726

Last change on this file since 726 was 726, checked in by Maciej Komosinski, 7 years ago
  • Changed Model::singleStepBuild() to Model::addFromString() to create model elements; the latter requires explicit indication of element type (P/J/N/C)
  • Removed old compatibility source (#ifdef MODEL_V1_COMPATIBLE) from f1->f0 converter and neuron definitions
  • Property svn:eol-style set to native
File size: 17.1 KB
Line 
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2017  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
4
5#include "conv_f1.h"
6#include <common/nonstd_stl.h>
7#include <common/log.h>
8#include <frams/util/multirange.h>
9#include <frams/util/multimap.h>
10#include <ctype.h>
11#include <assert.h>
12
13//#define v1f1COMPATIBLE //as in ancient Framsticks 1.x
14
15F1Props stdprops = { 1, 0, 1, 0.4, 0.25, 0.25, 0.25, 0.25, 0.0, 1.0, 1.0, 1,
16        0.2, 0.5, 0.5, 0.5 };
17
18class Builder
19{
20public:
21        Builder(const char*g, int mapping = 0) :invalid(0), genbegin(g), usemapping(mapping), first_part_mapping(NULL), own_first_part_mapping(true), model_energy(0), model_energy_count(0) {}
22        ~Builder() { if (own_first_part_mapping) SAFEDELETE(first_part_mapping); }
23        char tmp[222];
24        bool invalid;
25        Model model;
26        const char *genbegin;
27        SList neuro_f1_to_f0; // neuro_f1_to_f0(f1_refno) = actual neuro pointer
28        Neuro *last_f1_neuro;
29        SyntParam *neuro_cls_param;
30
31        struct Connection
32        {
33                int n1, n2; double w;
34                Connection(int _n1, int _n2, double _w) :n1(_n1), n2(_n2), w(_w) {}
35        };
36
37        SListTempl<Connection> connections;
38        int usemapping;
39        MultiRange range;
40        MultiRange *first_part_mapping;
41        bool own_first_part_mapping;
42        double lastjoint_muscle_power;
43        double model_energy;
44        int model_energy_count;
45        void grow(int part1, const char*g, Pt3D k, F1Props c, int branching_part);
46        void setPartMapping(int p, const char* g);
47        int growJoint(int part1, int part2, Pt3D &angle, F1Props &c, const char *g);
48        int growPart(F1Props &c, const char *g);
49        const char *skipNeuro(const char *z);
50        const char* growNeuro(const char* t, F1Props &c, int&);
51        void growConnection(const char* begin, const char* colon, const char* end, F1Props& props);
52        int countBranches(const char*g, SList &out);
53        SyntParam* lastNeuroClassParam();
54        void addClassParam(const char* name, double value);
55        void addClassParam(const char* name, const char* value);
56
57        const MultiRange* makeRange(const char*g) { return makeRange(g, g); }
58        const MultiRange* makeRange(const char*g, const char*g2);
59        Part *getLastPart() { return getLastJoint()->part2; }
60        Neuro *getLastNeuro() { return model.getNeuro(model.getNeuroCount() - 1); }
61        Joint *getLastJoint() { return model.getJoint(model.getJointCount() - 1); }
62        void addOrRememberInput(int n1, int n2, double w)
63        {
64                //if (!addInput(n1,n2,w,false))
65                connections += Connection(n1, n2, w);
66        }
67        bool addInput(int n1, int n2, double w, bool final)
68        {
69                if ((n1 < 0) || (n2 < 0) || (n1 >= neuro_f1_to_f0.size()) || (n2 >= neuro_f1_to_f0.size()))
70                {
71                        if (final) logPrintf("GenoConvF1", "addInput", LOG_WARN,
72                                "illegal neuron connection %d <- %d (ignored)", n1, n2);
73                        return 0;
74                }
75                Neuro *neuro = (Neuro*)neuro_f1_to_f0(n1);
76                Neuro *input = (Neuro*)neuro_f1_to_f0(n2);
77                neuro->addInput(input, w);
78                return 1;
79        }
80        void addPendingInputs()
81        {
82                for (int i = 0; i < connections.size(); i++)
83                {
84                        Connection *c = &connections(i);
85                        addInput(c->n1, c->n2, c->w, true);
86                }
87        }
88};
89
90const MultiRange* Builder::makeRange(const char*g, const char*g2)
91{
92        if (!usemapping) return 0;
93        range.clear();
94        range.add(g - genbegin, g2 - genbegin);
95        return &range;
96}
97
98void F1Props::normalizeBiol4()
99{
100        double sum = muscle_power + assimilation + stamina + ingestion;
101        muscle_power /= sum;
102        assimilation /= sum;
103        stamina /= sum;
104        ingestion /= sum;
105}
106
107/** main conversion function - with conversion map support */
108SString GenoConv_f1::convert(SString &i, MultiMap *map)
109{
110        const char* g = i.c_str();
111        Builder builder(g, map ? 1 : 0);
112        builder.model.open();
113        builder.grow(-1, g, Pt3D_0, stdprops, -1); // uses Model::addFromString() to create model elements
114        if (builder.invalid) return SString();
115        builder.addPendingInputs();
116        builder.model.startenergy = (builder.model_energy_count > 0) ? (builder.model_energy / builder.model_energy_count) : 1.0;
117        builder.model.close(); // model is ready to use now
118        if (map) builder.model.getCurrentToF0Map(*map); // generate f1-to-f0 conversion map
119        return builder.model.getF0Geno().getGenes();
120}
121
122void Builder::setPartMapping(int p, const char* g)
123{
124        if (!usemapping) return;
125        const MultiRange *r = makeRange(g);
126        if (p < 0)
127        { //special case: mapping the part which is not yet created
128                if (first_part_mapping) first_part_mapping->add(*r);
129                else { first_part_mapping = new MultiRange(*r); own_first_part_mapping = true; }
130        }
131        else
132                model.getPart(p)->addMapping(*r);
133}
134
135void Builder::grow(int part1, const char*g, Pt3D k, F1Props c, int branching_part)
136{
137        int hasmuscles = 0;
138        k += Pt3D(c.twist, 0, c.curvedness);
139        while (1)
140        {
141                switch (*g)
142                {
143                case 0: return;
144                case ',': case ')': setPartMapping(branching_part, g); return;
145                case 'R': k.x += 0.7853; setPartMapping(part1, g); break;
146                case 'r': k.x -= 0.7853;        setPartMapping(part1, g); break;
147                case 'Q': c.twist += (1.58 - c.twist)*0.3; setPartMapping(part1, g); break;
148                case 'q': c.twist += (-1.58 - c.twist)*0.3; setPartMapping(part1, g); break;
149#ifdef v1f1COMPATIBLE
150                case 'L': c.length += (3.0 - c.length)*0.3; setPartMapping(part1, g); break;
151#else
152                case 'L': c.length += (2.0 - c.length)*0.3; setPartMapping(part1, g); break;
153#endif                                       
154                case 'l': c.length += (0.33 - c.length)*0.3; setPartMapping(part1, g); break;
155                case 'A': c.assimilation += (1 - c.assimilation)*0.8;   c.normalizeBiol4(); setPartMapping(part1, g);  break;
156                case 'a': c.assimilation -= c.assimilation*0.4; c.normalizeBiol4(); setPartMapping(part1, g); break;
157                case 'I': c.ingestion += (1 - c.ingestion)*0.8; c.normalizeBiol4(); setPartMapping(part1, g); break;
158                case 'i': c.ingestion -= c.ingestion*0.4;       c.normalizeBiol4(); setPartMapping(part1, g); break;
159                case 'S': c.stamina += (1 - c.stamina)*0.8; c.normalizeBiol4(); setPartMapping(part1, g); break;
160                case 's': c.stamina -= c.stamina*0.4; c.normalizeBiol4(); setPartMapping(part1, g); break;
161                case 'M': c.muscle_power += (1 - c.muscle_power)*0.8;   c.normalizeBiol4(); setPartMapping(part1, g); break;
162                case 'm': c.muscle_power -= c.muscle_power*0.4; c.normalizeBiol4(); setPartMapping(part1, g); break;
163                case 'C': c.curvedness += (2.0 - c.curvedness)*0.25;    setPartMapping(part1, g); break;
164                case 'c': c.curvedness += (-2.0 - c.curvedness)*0.25; setPartMapping(part1, g); break;
165                case 'F': c.friction += (4 - c.friction)*0.2; setPartMapping(part1, g); break;
166                case 'f': c.friction -= c.friction*0.2; setPartMapping(part1, g); break;
167                case 'W': c.weight += (2.0 - c.weight)*0.3; setPartMapping(part1, g); break;
168                case 'w': c.weight += (0.5 - c.weight)*0.3; setPartMapping(part1, g); break;
169                case 'E': c.energy += (10.0 - c.energy)*0.1; setPartMapping(part1, g); break;
170                case 'e': c.energy -= c.energy*0.1;     setPartMapping(part1, g); break;
171
172                case 'D': c.cred += (1.0 - c.cred)*0.25; setPartMapping(part1, g); break;
173                case 'd': c.cred += (0.0 - c.cred)*0.25; setPartMapping(part1, g); break;
174                case 'G': c.cgreen += (1.0 - c.cgreen)*0.25; setPartMapping(part1, g); break;
175                case 'g': c.cgreen += (0.0 - c.cgreen)*0.25; setPartMapping(part1, g); break;
176                case 'B': c.cblue += (1.0 - c.cblue)*0.25; setPartMapping(part1, g); break;
177                case 'b': c.cblue += (0.0 - c.cblue)*0.25; setPartMapping(part1, g); break;
178                case 'H': c.visual_size += (0.7 - c.visual_size)*0.25; setPartMapping(part1, g); break;
179                case 'h': c.visual_size += (0.05 - c.visual_size)*0.25; setPartMapping(part1, g); break;
180
181                case '[': //neuron
182                        //              setdebug(g-(char*)geny,DEBUGNEURO | !l_neu);
183                        if (model.getJointCount())
184                                g = growNeuro(g + 1, c, hasmuscles);
185                        else
186                        {
187                                logMessage("GenoConv_F1", "grow", 1, "Illegal neuron position (ignored)");
188                                g = skipNeuro(g + 1);
189                        }
190                        break;
191                case 'X':
192                {
193                        int freshpart = 0;
194                        //setdebug(g-(char*)geny,DEBUGEST | !l_est);
195                        if (part1 < 0) //initial grow
196                        {
197                                if (model.getPartCount() > 0)
198                                        part1 = 0;
199                                else
200                                {
201                                        part1 = growPart(c, g);
202                                        freshpart = 1;
203                                        if (first_part_mapping)
204                                        {
205                                                //mapping was defined before creating this initial Part -> put it into the Part
206                                                assert(own_first_part_mapping);
207                                                model.getPart(part1)->setMapping(*first_part_mapping);
208                                                delete first_part_mapping;
209                                                //first_part_mapping can be still used later but from now on it references the internal Part mapping
210                                                first_part_mapping = model.getPart(part1)->getMapping();
211                                                own_first_part_mapping = false;
212                                        }
213                                }
214                        }
215                        if (!freshpart)
216                        {
217                                Part *part = model.getPart(part1);
218                                part->density = ((part->mass*part->density) + 1.0 / c.weight) / (part->mass + 1.0); // v=m*d
219                                //                      part->volume+=1.0/c.weight;
220                                part->mass += 1.0;
221                        }
222                        model_energy += 0.9*c.energy + 0.1;
223                        model_energy_count++;
224
225                        int part2 = growPart(c, g);
226                        growJoint(part1, part2, k, c, g);
227                        //              est* e = new est(*s,*s2,k,c,zz,this);
228
229                        // attenuate properties as they are propagated along the structure
230                        c.length = 0.5*c.length + 0.5*stdprops.length;
231                        c.visual_size = 0.5*c.visual_size + 0.5*stdprops.visual_size;
232                        c.curvedness = 0.66*c.curvedness;
233                        c.twist = 0.66*c.twist;
234                        c.friction = 0.8*c.friction + 0.2*stdprops.friction;
235
236                        c.assimilation = 0.8*c.assimilation + 0.2*stdprops.assimilation;
237                        c.stamina = 0.8*c.stamina + 0.2*stdprops.stamina;
238                        c.muscle_power = 0.8*c.muscle_power + 0.2*stdprops.muscle_power;
239                        c.ingestion = 0.8*c.ingestion + 0.2*stdprops.ingestion;
240                        c.weight += (stdprops.weight - c.weight)*0.5;
241                        c.normalizeBiol4();
242
243                        if (c.muscle_reset_range) c.muscle_bend_range = 1.0; else c.muscle_reset_range = true;
244                        grow(part2, g + 1, Pt3D_0, c, branching_part);
245                        return;
246                }
247                case '(':
248                {
249                        setPartMapping(part1, g);
250                        SList ga;
251                        int i, count;
252                        count = countBranches(g + 1, ga);
253                        c.muscle_reset_range = false;
254                        c.muscle_bend_range = 1.0 / count;
255                        for (i = 0; i < count; i++)
256                                grow(part1, (char*)ga(i), k + Pt3D(0, 0, -M_PI + (i + 1)*(2 * M_PI / (count + 1))), c, part1);
257                        return;
258                }
259                case ' ': case '\t': case '\n': case '\r': break;
260                default: invalid = 1; return;
261                }
262                g++;
263        }
264}
265
266SyntParam* Builder::lastNeuroClassParam()
267{
268        if (!neuro_cls_param)
269        {
270                NeuroClass *cls = last_f1_neuro->getClass();
271                if (cls)
272                {
273                        neuro_cls_param = new SyntParam(last_f1_neuro->classProperties());
274                        // this is equivalent to:
275                        //              SyntParam tmp=last_f1_neuro->classProperties();
276                        //              neuro_cls_param=new SyntParam(tmp);
277                        // interestingly, some compilers eliminate the call to new SyntParam,
278                        // realizing that a copy constructor is redundant when the original object is
279                        // temporary. there are no side effect of such optimization, as long as the
280                        // copy-constructed object is exact equivalent of the original.
281                }
282        }
283        return neuro_cls_param;
284}
285
286void Builder::addClassParam(const char* name, double value)
287{
288        lastNeuroClassParam();
289        if (neuro_cls_param)
290                neuro_cls_param->setDoubleById(name, value);
291}
292
293void Builder::addClassParam(const char* name, const char* value)
294{
295        lastNeuroClassParam();
296        if (neuro_cls_param)
297        {
298                ExtValue e(value);
299                const ExtValue &re(e);
300                neuro_cls_param->setById(name, re);
301        }
302}
303
304int Builder::countBranches(const char*g, SList &out)
305{
306        int gl = 0;
307        out += (void*)g;
308        while (gl >= 0)
309        {
310                switch (*g)
311                {
312                case 0: gl = -1; break;
313                case '(': case '[': ++gl; break;
314                case ')': case ']': --gl; break;
315                case ',': if (!gl) out += (void*)(g + 1);
316                }
317                g++;
318        }
319        return out.size();
320}
321
322int Builder::growJoint(int part1, int part2, Pt3D &angle, F1Props &c, const char *g)
323{
324        double len = min(2.0, c.length);
325        sprintf(tmp, "p1=%ld,p2=%ld,dx=%lg,rx=%lg,ry=%lg,rz=%lg,stam=%lg,vr=%g,vg=%g,vb=%g",
326                part1, part2, len, angle.x, angle.y, angle.z, c.stamina, c.cred, c.cgreen, c.cblue);
327        lastjoint_muscle_power = c.muscle_power;
328        return model.addFromString(Model::JointType, tmp, makeRange(g));
329}
330
331int Builder::growPart(F1Props &c, const char *g)
332{
333        sprintf(tmp, "dn=%lg,fr=%lg,ing=%lg,as=%lg,vs=%g,vr=%g,vg=%g,vb=%g",
334                1.0 / c.weight, c.friction, c.ingestion, c.assimilation, c.visual_size, c.cred, c.cgreen, c.cblue);
335        return model.addFromString(Model::PartType, tmp, makeRange(g));
336}
337
338const char *Builder::skipNeuro(const char *z)
339{
340        for (; *z; z++) if ((*z == ']') || (*z == ')')) break;
341        return z - 1;
342}
343
344const char* Builder::growNeuro(const char* t, F1Props& props, int &hasmuscles)
345{
346        const char*neuroend = skipNeuro(t);
347        last_f1_neuro = model.addNewNeuro();
348        neuro_cls_param = NULL;
349        last_f1_neuro->attachToPart(getLastPart());
350        const MultiRange *mr = makeRange(t - 1, neuroend + 1);
351        if (mr) last_f1_neuro->addMapping(*mr);
352        neuro_f1_to_f0 += last_f1_neuro;
353
354        SString clsname;
355        bool haveclass = 0;
356        while (*t && *t <= ' ') t++;
357        const char* next = (*t) ? (t + 1) : t;
358        while (*next && *next <= ' ') next++;
359        if (*t && *next != ',' && *next != ']') // old style muscles [|rest] or [@rest]
360                switch (*t)
361        {
362                case '@': if (t[1] == ':') break;
363                        haveclass = 1;
364                        //              if (!(hasmuscles&1))
365                        {
366                                hasmuscles |= 1;
367                                Neuro *muscle = model.addNewNeuro();
368                                sprintf(tmp, "@:p=%lg", lastjoint_muscle_power);
369                                muscle->addInput(last_f1_neuro);
370                                muscle->setDetails(tmp);
371                                muscle->attachToJoint(getLastJoint());
372                                if (usemapping) muscle->addMapping(*makeRange(t));
373                        }
374                        t++;
375                        break;
376                case '|': if (t[1] == ':') break;
377                        haveclass = 1;
378                        //              if (!(hasmuscles&2))
379                        {
380                                hasmuscles |= 2;
381                                Neuro *muscle = model.addNewNeuro();
382                                sprintf(tmp, "|:p=%lg,r=%lg", lastjoint_muscle_power, props.muscle_bend_range);
383                                muscle->addInput(last_f1_neuro);
384                                muscle->setDetails(tmp);
385                                muscle->attachToJoint(getLastJoint());
386                                if (usemapping) muscle->addMapping(*makeRange(t));
387                        }
388                        t++;
389                        break;
390        }
391        while (*t && *t <= ' ') t++;
392        bool finished = 0;
393        const char *begin = t;
394        const char* colon = 0;
395        SString classparams;
396        while (!finished)
397        {
398                switch (*t)
399                {
400                case ':': colon = t; break;
401                case 0: case ']': case ')': finished = 1;
402                        // NO break!
403                case ',':
404                        if (!haveclass && !colon && t > begin)
405                        {
406                                haveclass = 1;
407                                SString clsname(begin, t - begin);
408                                clsname = trim(clsname);
409                                last_f1_neuro->setClassName(clsname);
410                                NeuroClass *cls = last_f1_neuro->getClass();
411                                if (cls)
412                                {
413                                        if (cls->getPreferredLocation() == 2)
414                                                last_f1_neuro->attachToJoint(getLastJoint());
415                                        else if (cls->getPreferredLocation() == 1)
416                                                last_f1_neuro->attachToPart(getLastPart());
417
418                                        lastNeuroClassParam();
419                                        //special handling: muscle properties (can be overwritten by subsequent property assignments)
420                                        if (!strcmp(cls->getName().c_str(), "|"))
421                                        {
422                                                neuro_cls_param->setDoubleById("p", lastjoint_muscle_power);
423                                                neuro_cls_param->setDoubleById("r", props.muscle_bend_range);
424                                        }
425                                        else if (!strcmp(cls->getName().c_str(), "@"))
426                                        {
427                                                neuro_cls_param->setDoubleById("p", lastjoint_muscle_power);
428                                        }
429                                }
430                        }
431                        else if (colon && (colon > begin) && (t > colon))
432                                growConnection(begin, colon, t, props);
433                        if (t[0] != ',') t--;
434                        begin = t + 1; colon = 0;
435                        break;
436                }
437                t++;
438        }
439        SAFEDELETE(neuro_cls_param);
440        return t;
441}
442void Builder::growConnection(const char* begin, const char* colon, const char* end, F1Props& props)
443{
444        while (*begin && *begin <= ' ') begin++;
445        int i;
446        if (isdigit(begin[0]) || (begin[0] == '-'))
447        {
448                double conn_weight = ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str());
449                paInt relative = ExtValue::getInt(trim(SString(begin, colon - begin)).c_str(), false);
450                int this_refno = neuro_f1_to_f0.size() - 1;
451                addOrRememberInput(this_refno, this_refno + relative, conn_weight);
452        }
453        else if ((i = last_f1_neuro->extraProperties().findIdn(begin, colon - begin)) >= 0)
454        {
455                last_f1_neuro->extraProperties().set(i, colon + 1);
456        }
457        else if (isupper(begin[0]) || strchr("*|@", begin[0]))
458        {
459                SString clsname(begin, colon - begin);
460                trim(clsname);
461                Neuro *receptor = model.addNewNeuro();
462                receptor->setClassName(clsname);
463                NeuroClass *cls = receptor->getClass();
464                if (cls)
465                {
466                        if (cls->getPreferredLocation() == 2) receptor->attachToJoint(getLastJoint());
467                        else if (cls->getPreferredLocation() == 1) receptor->attachToPart(getLastPart());
468                }
469                last_f1_neuro->addInput(receptor, ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str()));
470                if (usemapping) receptor->addMapping(*makeRange(begin, end - 1));
471        }
472        else if ((begin[0] == '>') && (begin[1]))
473        {
474                Neuro *out = model.addNewNeuro();
475                out->addInput(last_f1_neuro, ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str()));
476                out->setClassName(SString(begin + 1, end - colon - 1));
477                if (begin[1] == '@')
478                {
479                        sprintf(tmp, "p=%lg", lastjoint_muscle_power);
480                        out->setClassParams(tmp);
481                }
482                else if (begin[1] == '|')
483                {
484                        sprintf(tmp, "p=%lg,r=%lg", lastjoint_muscle_power, props.muscle_bend_range);
485                        out->setClassParams(tmp);
486                }
487                NeuroClass *cls = out->getClass();
488                if (cls)
489                {
490                        if (cls->getPreferredLocation() == 2) out->attachToJoint(getLastJoint());
491                        else if (cls->getPreferredLocation() == 1) out->attachToPart(getLastPart());
492                }
493                if (usemapping) out->addMapping(*makeRange(begin, end - 1));
494        }
495        else if (*begin == '!') addClassParam("fo", ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str()));
496        else if (*begin == '=') addClassParam("in", ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str()));
497        else if (*begin == '/') addClassParam("si", ExtValue::getDouble(trim(SString(colon + 1, end - (colon + 1))).c_str()));
498        else if (islower(begin[0]))
499        {
500                SString name(begin, colon - begin);
501                SString value(colon + 1, end - (colon + 1));
502                addClassParam(name.c_str(), value.c_str());
503        }
504}
Note: See TracBrowser for help on using the repository browser.