2d_lsystems.cpp

//
// Created by Kobe De Broeck on 3-4-2022.
//

#include "2d_lsystems.h"

#include <stack>
#include "l_parser.h"
#include <fstream>
#include "line_drawing_utils.h"

using namespace std;


namespace KDBRenderUtils {

    struct PenState {
        Point2D cur;
        double angle;
        double angleDelta;
        NormColor color;
    };

    static std::stack<PenState> penStateStack;

    static PenState penState;

    void drawLSystemRecursive(
            int nrIterations,
            const std::string& penInstructions,
            std::vector<Line2D>& lines,
            const LParser::LSystem2D& lSystem
    );

    std::vector<Line2D> drawLSystem(const LParser::LSystem2D& lSystem, NormColor lineColor )
    {
        std::vector<Line2D> lines;

        penState.cur = {0,0};
        penState.angleDelta = rad(lSystem.get_angle());
        penState.angle = rad(lSystem.get_starting_angle());
        penState.color = lineColor;

        drawLSystemRecursive(lSystem.get_nr_iterations(), lSystem.get_initiator(), lines, lSystem);

        return lines;
    }

    void drawLSystemRecursive(
            int nrIterations,
            const std::string& penInstructions,
            std::vector<Line2D>& lines,
            const LParser::LSystem2D& lSystem
    )
    {
        for( char c : penInstructions) {
            if( lSystem.get_alphabet().find(c) != lSystem.get_alphabet().end())
            {
                if(nrIterations <= 0) {
                    auto next = penState.cur + Point2D{cos(penState.angle), sin(penState.angle)};

                    if(lSystem.draw(c)) {
                        lines.push_back({penState.cur, next, penState.color, 0, 0});
                    }
                    penState.cur = next;

                    continue;
                }
                drawLSystemRecursive(nrIterations-1, lSystem.get_replacement(c), lines, lSystem);
                continue;
            }
            if( c == '(') {
                penStateStack.push(penState);
                continue;
            }
            if(c == ')') {
                penState = penStateStack.top();
                penStateStack.pop();
                continue;
            }
            if( c == '+') {
                penState.angle += penState.angleDelta;
                continue;
            }
            if(c == '-') {
                penState.angle -= penState.angleDelta;
                continue;
            }
        }
    }

    img::EasyImage draw2DLSystem(const ini::Configuration& configuration)
    {
        if(configuration["General"]["type"].as_string_or_default("") != "2DLSystem") {
            cerr << "draw2DLSystem didn't get a 2DLSystem config!\n";
            return {};
        }

        unsigned size = configuration["General"]["size"].as_int_or_default(0);
        auto backgroundColorVec = configuration["General"]["backgroundcolor"].as_double_tuple_or_default({0,0,0});

        std::string inputFile = configuration["2DLSystem"]["inputfile"].as_string_or_die();
        auto lineColorVec = configuration["2DLSystem"]["color"].as_double_tuple_or_default({1,0,1});
        NormColor lineColor = toNormColor(lineColorVec);

        LParser::LSystem2D lSystem;
        std::ifstream ifs{inputFile};
        ifs >> lSystem;
        if(!ifs) std::cerr << "Couldn't read l-system\n";

        std::vector<Line2D> lines = drawLSystem(lSystem, lineColor);
        //return draw2DLines(lines, size, vec_to_color(backgroundColorVec));
        img::EasyImage result;
        result = draw2DLines(lines, size, toNormColor(backgroundColorVec));
        // Om de move constructor en move assignment uit te testen, moeten we copy elision voorkomen.
        // Dit doen we door result te muteren voor dat we ze terug te geven aan de caller
        result(0,0) = img::Color{1,2,3};
        return result;
    }

}