Changeset 1030 for cpp/frams/genetics/fS/fS_general.cpp

Timestamp:

11/26/20 01:30:40 (3 years ago)

Author:

Maciej Komosinski

Message:

fS: refactoring

File:

• cpp/frams/genetics/fS/fS_general.cpp (modified) (25 diffs)

cpp/frams/genetics/fS/fS_general.cpp

@@ -15 +15 @@
 
 int fS_Genotype::precision = 4;
-bool fS_Genotype::TURN_WITH_ROTATION = false;
 std::map<string, double> Node::minValues;
 std::map<string, double> Node::defaultValues;
@@ -33 +32 @@
                                 {RY,        -M_PI},
                                 {RZ,        -M_PI},
-                                {SIZE,      0.01},
-                                {SIZE_X,    Model::getMinPart().scale.x},
-                                {SIZE_Y,    Model::getMinPart().scale.y},
-                                {SIZE_Z,    Model::getMinPart().scale.z}
+                                {SCALE,      0.01},
+                                {SCALE_X,    Model::getMinPart().scale.x},
+                                {SCALE_Y,    Model::getMinPart().scale.y},
+                                {SCALE_Z,    Model::getMinPart().scale.z}
                 };
         }
@@ -51 +50 @@
                                 {RY,        M_PI},
                                 {RZ,        M_PI},
-                                {SIZE,      100.0},
-                                {SIZE_X,    Model::getMaxPart().scale.x},
-                                {SIZE_Y,    Model::getMaxPart().scale.y},
-                                {SIZE_Z,    Model::getMaxPart().scale.z}
+                                {SCALE,      100.0},
+                                {SCALE_X,    Model::getMaxPart().scale.x},
+                                {SCALE_Y,    Model::getMaxPart().scale.y},
+                                {SCALE_Z,    Model::getMaxPart().scale.z}
                 };
         }
@@ -68 +67 @@
                                 {RY,        0.0},
                                 {RZ,        0.0},
-                                {SIZE,      1.0},
-                                {SIZE_X,    Model::getDefPart().scale.x},
-                                {SIZE_Y,    Model::getDefPart().scale.y},
-                                {SIZE_Z,    Model::getDefPart().scale.z}
+                                {SCALE,      1.0},
+                                {SCALE_X,    Model::getDefPart().scale.x},
+                                {SCALE_Y,    Model::getDefPart().scale.y},
+                                {SCALE_Z,    Model::getDefPart().scale.z}
                 };
         }
@@ -111 +110 @@
 }
 
+void rotateVector(Pt3D &vector, const Pt3D &rotation)
+{
+        Orient rotmatrix = Orient_1;
+        rotmatrix.rotate(rotation);
+        vector = rotmatrix.transform(vector);
+}
+
 void State::rotate(const Pt3D &rotation)
 {
-       fS_Utils::rotateVector(v, rotation);
+       rotateVector(v, rotation);
        v.normalize();
 }
@@ -218 +224 @@
 void Node::extractModifiers(Substring &restOfGenotype)
 {
-        int partTypePosition = getPartPosition(restOfGenotype);
-        if (partTypePosition == -1)
+        int partShapePosition = getPartPosition(restOfGenotype);
+        if (partShapePosition == -1)
                 throw fS_Exception("Part type missing", restOfGenotype.start);
 
-        for (int i = 0; i < partTypePosition; i++)
+        for (int i = 0; i < partShapePosition; i++)
         {
                 // Extract modifiers and joint
@@ -233 +239 @@
                         throw fS_Exception("Invalid modifier", restOfGenotype.start + i);
         }
-        restOfGenotype.startFrom(partTypePosition);
+        restOfGenotype.startFrom(partShapePosition);
 }
 
@@ -242 +248 @@
                 throw fS_Exception("Invalid part type", restOfGenotype.start);
 
-        partType = itr->second;
+        partShape = itr->second;
         restOfGenotype.startFrom(1);
 }
@@ -327 +333 @@
                 size_t len = length - valueStartIndex;
                 double value = fS_stod(val, restOfGenotype.start + start + valueStartIndex, &len);
-                if((key==SIZE_X || key==SIZE_Y || key==SIZE_Z) && value <= 0.0)
+                if((key==SCALE_X || key==SCALE_Y || key==SCALE_Z) && value <= 0.0)
                         throw fS_Exception("Invalid value of radius parameter", restOfGenotype.start + start + valueStartIndex);
 
@@ -342 +348 @@
         if (item != params.end())
                 return item->second;
-        return defaultValues.at(key);
+
+        auto defaultItem = defaultValues.find(key);
+        if(defaultItem == defaultValues.end())
+                throw fS_Exception("Default value missing", 0);
+        return defaultItem->second;
 }
 
@@ -382 +392 @@
                 state->rotate(getVectorRotation());
 
-                double distance = getDistance();
+                double distance = calculateDistanceFromParent();
                 state->addVector(distance);
         }
@@ -433 +443 @@
 }
 
-void Node::calculateSize(Pt3D &scale)
-{
-        double sizeMultiplier = getParam(SIZE) * state->s;
-        scale.x = getParam(SIZE_X) * sizeMultiplier;
-        scale.y = getParam(SIZE_Y) * sizeMultiplier;
-        scale.z = getParam(SIZE_Z) * sizeMultiplier;
+void Node::calculateScale(Pt3D &scale)
+{
+        double scaleMultiplier = getParam(SCALE) * state->s;
+        scale.x = getParam(SCALE_X) * scaleMultiplier;
+        scale.y = getParam(SCALE_Y) * scaleMultiplier;
+        scale.z = getParam(SCALE_Z) * scaleMultiplier;
 }
 
@@ -444 +454 @@
 {
         double result;
-        Pt3D size;
-        calculateSize(size);
-        double radiiProduct = size.x * size.y * size.z;
-        switch (partType)
+        Pt3D scale;
+        calculateScale(scale);
+        double radiiProduct = scale.x * scale.y * scale.z;
+        switch (partShape)
         {
                 case Part::Shape::SHAPE_CUBOID:
@@ -464 +474 @@
 }
 
-bool Node::isPartSizeValid()
-{
-        Pt3D size;
-        calculateSize(size);
+bool Node::isPartScaleValid()
+{
+        Pt3D scale;
+        calculateScale(scale);
         double volume = calculateVolume();
         Part_MinMaxDef minP = Model::getMinPart();
@@ -474 +484 @@
         if (volume > maxP.volume || minP.volume > volume)
                 return false;
-        if (size.x < minP.scale.x || size.y < minP.scale.y || size.z < minP.scale.z)
+        if (scale.x < minP.scale.x || scale.y < minP.scale.y || scale.z < minP.scale.z)
                 return false;
-        if (size.x > maxP.scale.x || size.y > maxP.scale.y || size.z > maxP.scale.z)
+        if (scale.x > maxP.scale.x || scale.y > maxP.scale.y || scale.z > maxP.scale.z)
                 return false;
 
-        if (partType == Part::Shape::SHAPE_ELLIPSOID && fS_Utils::max3(size) != fS_Utils::min3(size))
+        if (partShape == Part::Shape::SHAPE_ELLIPSOID && scale.maxComponentValue() != scale.minComponentValue())
                 // When not all radii have different values
                 return false;
-        if (partType == Part::Shape::SHAPE_CYLINDER && size.y != size.z)
+        if (partShape == Part::Shape::SHAPE_CYLINDER && scale.y != scale.z)
                 // If base radii have different values
                 return false;
@@ -488 +498 @@
 }
 
-bool Node::hasPartSizeParam()
-{
-        return params.count(SIZE_X) > 0 || params.count(SIZE_Y) > 0 || params.count(SIZE_Z) > 0;
-}
-
 Pt3D Node::getVectorRotation()
 {
@@ -501 +506 @@
 {
         Pt3D rotation = Pt3D(getParam(RX, 0.0), getParam(RY, 0.0), getParam(RZ, 0.0));
-        if(fS_Genotype::TURN_WITH_ROTATION)
+        if(genotypeParams.turnWithRotation)
                 rotation += getVectorRotation();
         return rotation;
@@ -537 +542 @@
 void Node::createPart()
 {
-        part = new Part(partType);
+        part = new Part(partShape);
         part->p = Pt3D(state->location);
 
         part->friction = getParam(FRICTION) * state->fr;
         part->ingest = getParam(INGESTION) * state->ing;
-        calculateSize(part->scale);
+        calculateScale(part->scale);
         part->setRot(getRotation());
 }
@@ -581 +586 @@
                 result += std::string(count, mod).c_str();
         }
-        result += SHAPE_TO_GENE.at(partType);
+        result += SHAPE_TO_GENE.at(partShape);
 
         if (!neurons.empty())
@@ -658 +663 @@
 }
 
-fS_Genotype::fS_Genotype(const string &geno)
-{
+fS_Genotype::fS_Genotype(const string &g)
+{
+        string geno(g);
+        geno.erase(remove(geno.begin(), geno.end(), ' '), geno.end());
+        geno.erase(remove(geno.begin(), geno.end(), '\n'), geno.end());
         try
         {
                 GenotypeParams genotypeParams;
                 genotypeParams.modifierMultiplier = 1.1;
+                genotypeParams.distanceTolerance = 0.1;
+                genotypeParams.relativeDensity = 10.0;
+                genotypeParams.turnWithRotation = false;
+                genotypeParams.paramMutationStrength = 0.4;
 
                 size_t modeSeparatorIndex = geno.find(MODE_SEPARATOR);
@@ -669 +681 @@
                         throw fS_Exception("Genotype parameters missing", 0);
 
-                genotypeParams.modifierMultiplier = fS_stod(geno, 0, &modeSeparatorIndex);
+                std::vector<SString> paramStrings;
+                strSplit(SString(geno.c_str(), modeSeparatorIndex), ',', false, paramStrings);
+
+                if(paramStrings.size() >= 1 && paramStrings[0] != "")
+                {
+                        size_t len0 = paramStrings[0].length();
+                        genotypeParams.modifierMultiplier = fS_stod(paramStrings[0].c_str(), 0, &len0);
+                }
+                if(paramStrings.size() >= 2 && paramStrings[1] != "")
+                {
+                        genotypeParams.turnWithRotation = bool(atoi(paramStrings[1].c_str()));
+                }
+                if(paramStrings.size() >= 3 && paramStrings[2] != "")
+                {
+                        size_t len2 = paramStrings[2].length();
+                        genotypeParams.paramMutationStrength = fS_stod(paramStrings[2].c_str(), 0, &len2);
+                }
 
                 int genoStart = modeSeparatorIndex + 1;
@@ -680 +708 @@
                 delete startNode;
                 throw e;
+        }
+        catch(...)
+        {
+                delete startNode;
+                throw fS_Exception("Unknown exception in fS", 0);
         }
 }
@@ -753 +786 @@
         geno.reserve(100);
 
-        geno += doubleToString(startNode->genotypeParams.modifierMultiplier, fS_Genotype::precision).c_str();
+        GenotypeParams gp = startNode->genotypeParams;
+        geno += doubleToString(gp.modifierMultiplier, precision).c_str();
+        geno += ",";
+        geno += doubleToString(gp.turnWithRotation, precision).c_str();
+        geno += ",";
+        geno += doubleToString(gp.paramMutationStrength, precision).c_str();
         geno += MODE_SEPARATOR;
 
@@ -850 +888 @@
         for (int i = 0; i < int(nodes.size()); i++)
         {
-                if (!nodes[i]->isPartSizeValid())
+                if (!nodes[i]->isPartScaleValid())
                 {
                         return 1 + nodes[i]->partDescription->start;
@@ -884 +922 @@
 }
 
+double Node::calculateDistanceFromParent()
+{
+        Pt3D scale;
+        calculateScale(scale);
+        Pt3D parentScale;
+        parent->calculateScale(parentScale);    // Here we are sure that parent is not nullptr
+        Part *tmpPart = PartDistanceEstimator::buildTemporaryPart(partShape, scale, getRotation());
+        Part *parentTmpPart = PartDistanceEstimator::buildTemporaryPart(parent->partShape, parentScale, parent->getRotation());
+
+        double result;
+        try
+        {
+                tmpPart->p = state->v;
+                result = PartDistanceEstimator::calculateDistance(*tmpPart, *parentTmpPart, genotypeParams.distanceTolerance, genotypeParams.relativeDensity);
+        }
+        catch (...)
+        {
+                throw fS_Exception("Exception thrown while calculating distance from parent", 0);
+        }
+
+        delete tmpPart;
+        delete parentTmpPart;
+        return result;
+}