source: cpp/frams/genetics/f9/f9_conv.cpp @ 1336

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2025  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#include "f9_conv.h"
#include <frams/model/model.h>
#include <string.h>

#define APPLY_DETERMINISTIC_BODY_NOISE //this genetic representation easily produces perfectly vertical sticks that would stay upright forever in simulation. In most cases such infinite perfection is not desired, so we make the construct less perfect by perturbing its coordinates.

GenoConv_f90::GenoConv_f90()
{
        name = "Turtle3D-ortho encoding";
        in_format = '9';
        out_format = '0';
        mapsupport = 1;
}


const char* turtle_commands_f9 = "LRBFDU";
int turtle_commands_f9_count = 6; //keep in sync, must equal strlen(turtle_commands_f9)

//const char* turtle_commandsX_f9="-+0000";
//const char* turtle_commandsY_f9="00-+00";
//const char* turtle_commandsZ_f9="0000-+";

SString GenoConv_f90::convert(SString &in, MultiMap *map, bool using_checkpoints)
{
        vector<XYZ_LOC> vertices;
        XYZ_LOC current;
        Model m;
        m.open(using_checkpoints);
        int recently_added = addSegment(m, 0, vertices, current, 0xDead);
        for (int i = 0; i < in.length(); i++)
        {
                char command = in[i];
                char *ptr = strchr((char*)turtle_commands_f9, command);
                if (ptr)
                {
                        int delta[] = { 0, 0, 0 };
                        int pos = ptr - turtle_commands_f9;
                        int axis = pos / 2;
                        int dir = pos % 2;
                        (*(delta + axis)) += dir * 2 - 1; //+1 or -1 in the given axis
                        current.add(delta);
                        recently_added = addSegment(m, i, vertices, current, recently_added);
                        m.checkpoint();
                }
        }
#ifdef APPLY_DETERMINISTIC_BODY_NOISE
        perturbPartLocations(m);
#endif
        setColors(m, recently_added);
        m.close();
        if (m.getPartCount() < 2) //only one part <=> there were no valid turtle commands in the input genotype
                return ""; //so we return an invalid f0 genotype
        if (map != NULL)
                m.getCurrentToF0Map(*map);
        return m.getF0Geno().getGenes();
}

int GenoConv_f90::addSegment(Model &m, int genenr, vector<XYZ_LOC> &vertices, const XYZ_LOC &new_vertex, int recently_added)
{
        if (vertices.size() < 1) //empty model?
        {
                return addNewVertex(m, vertices, new_vertex);
        }
        else
        {
                int vertex_here = findVertexAt(vertices, new_vertex);
                if (vertex_here < 0) //need to create a new Part
                {
                        vertex_here = addNewVertex(m, vertices, new_vertex);
                } //else there already exists a Part in new_vertex; new Joint may or may not be needed
                Part *p1 = m.getPart(recently_added);
                Part *p2 = m.getPart(vertex_here);
                p1->addMapping(MultiRange(genenr, genenr));
                p2->addMapping(MultiRange(genenr, genenr));

                int j12 = m.findJoint(p1, p2);
                int j21 = m.findJoint(p2, p1);
                if (j12 >= 0)
                        m.getJoint(j12)->addMapping(MultiRange(genenr, genenr));
                else if (j21 >= 0)
                        m.getJoint(j21)->addMapping(MultiRange(genenr, genenr));
                else //both j12<0 and j21<0. New Joint needed. Should always happen if we just created a new Part (vertex_here was <0)
                        m.addNewJoint(p1, p2)->addMapping(MultiRange(genenr, genenr));
                return vertex_here;
        }
}

int GenoConv_f90::findVertexAt(vector<XYZ_LOC> &vertices, const XYZ_LOC &vertex)
{
        for (int i = 0; i < (int)vertices.size(); i++)
                if (vertices[i].same_coordinates(vertex)) return i;
        return -1;
}


int GenoConv_f90::addNewVertex(Model &m, vector<XYZ_LOC> &vertices, const XYZ_LOC &new_vertex)
{
        Part *p = new Part;
        p->p.x = new_vertex.x;
        p->p.y = new_vertex.y;
        p->p.z = new_vertex.z;
        m.addPart(p);

        vertices.push_back(new_vertex);
        return int(vertices.size()) - 1;
}

double mix(int *colortab, int maxind, double ind)
{
        int indpre = (int)ind;
        int indpost = indpre + 1;
        if (indpost > maxind) indpost = maxind;
        int v1 = colortab[indpre];
        int v2 = colortab[indpost];
        double d1 = ind - indpre;
        double d2 = indpost - ind;
        double v = indpre == indpost ? v1 : d2 * v1 + d1 * v2; //d1+d2==1
        return v;
}

void GenoConv_f90::setColors(Model &m, int last_added_part) //sets fixed (independent from genes) colors and widths on a model, purely for aesthetic purposes
{
        static const bool OLD = false; //old "rainbow" hue gradient
        if (OLD)
        {
                //a rainbow on Joints: from the first one red, through middle green, to blue or violet - last
                static int r[] = { 1, 1, 0, 0, 0, 1 };
                static int g[] = { 0, 1, 1, 1, 0, 0 };
                static int b[] = { 0, 0, 0, 1, 1, 1 };
                int maxind = int(std::size(r)) - 1;

                int joints_count = m.getJointCount();
                for (int i = 0; i < joints_count; i++)
                {
                        Joint *j = m.getJoint(i);
                        double x = joints_count < 2 ? 0 : (double)i / (joints_count - 1); //0..1, position in the rainbow
                        double ind = x * maxind;
                        j->vcolor.x = mix(r, maxind, ind);
                        j->vcolor.y = mix(g, maxind, ind);
                        j->vcolor.z = mix(b, maxind, ind);
                }
        }
        else
        {
                int joints_count = m.getJointCount();
                for (int i = 0; i < joints_count; i++)
                {
                        Joint *j = m.getJoint(i);
                        Pt3D d = j->part2->p - j->part1->p; //dx,dy,dz
                        double ax = fabs(d.x), ay = fabs(d.y), az = fabs(d.z);
                        // Pairs of colors should be easy to associate as "one family" at a glance, but different so that we use all main six parts of the spectrum.
                        // Colors are slightly brightened to make them more pastel/plastic; extreme saturation pure red=1,0,0 or blue 0,0,1 do not look good.
                        // Find the longest axis (i.e., recover the information from the genotype: was this joint created by LR, BF, or DU?)
                        if ((ax > ay) && (ax > az)) // x
                        {
                                j->vcolor = d.x < 0 ? Pt3D(1, 0.2, 0.2) : Pt3D(1, 0.2, 0.6); // red, purple red
                        }
                        else
                                if ((ay > ax) && (ay > az)) // y
                                {
                                        j->vcolor = d.y < 0 ? Pt3D(0.2, 1, 0.2) : Pt3D(0.7, 1, 0.2); //green, yellowish green
                                }
                                else // z
                                {
                                        j->vcolor = d.z < 0 ? Pt3D(0.2, 0.2, 1) : Pt3D(0.4, 0.9, 1); //blue, cyanish blue
                                }
                }
        }

        int parts_count = m.getPartCount();
        if (OLD)
        {
                SList jlist;
                for (int i = 0; i < parts_count; i++)
                {
                        Part *p = m.getPart(i);
                        jlist.clear();
                        int count = m.findJoints(jlist, p);
                        Pt3D averagecolor(0, 0, 0); //Parts will get averaged colors from all attached Joints
                        FOREACH(Joint*, j, jlist)
                                averagecolor += j->vcolor;
                        p->vcolor = averagecolor / count;
                }
        }
        else
        {
                //Parts will get gray colors from darker to brighter, according to their order of creation.
                for (int i = 0; i < parts_count; i++)
                {
                        Part *p = m.getPart(i);
                        p->vcolor.x = p->vcolor.y = p->vcolor.z = 0.3 + 0.4 * i / (parts_count - 1); //0.3..0.7, so first (black) and last (white) stand out more
                }
        }
        //The first Part will be black, the last Part will be white - a visual aid for easier matching of the genotype and the corresponding phenotype.
        if (!OLD)
                m.getPart(0)->vcolor = Pt3D(0, 0, 0); //mark first Part black - not attractive in OLD sweet and positive color scheme
        m.getPart(last_added_part)->vcolor = Pt3D(1, 1, 1); //mark last Part white
}

void GenoConv_f90::perturbPartLocations(Model &m) //deterministic "body noise", see APPLY_DETERMINISTIC_BODY_NOISE
{
        for (int i = 0; i < m.getPartCount(); i++)
        {
                Part *p = m.getPart(i);
                Pt3D noise(
                        ((i + 1) % 10) - 4.5,
                        ((3 * i + 5) % 10) - 4.5,
                        ((7 * i + 2) % 10) - 4.5
                ); //-4.5 .. 4.5 in each axis
                p->p += noise / 1000;
        }
}