~masgk3team/masgk3/roads

#include "LSystemGenerator.hpp"

#include "RoadJunctionPoint.hpp"

#include "Road.hpp"

//-----//

#include <cmath>

#include <QImage>

//-----//

#include <QDebug>

//-----//

Utils::Junctions LSystemGenerator::GenerateRoads(const ConfigRoads &c, const QImage *inputImage)

{

    const ConfigLSystemRoads conf = *((ConfigLSystemRoads*)&c);

    const QSize mapSize = inputImage->size();

    //QVector2D tmpVec((float)rand()/RAND_MAX, (float)rand()/RAND_MAX);

    QVector2D tmpVec(1, 0);

    QList<LSystemState> aStack;

    int drawLength = 8,

        drawLength2 = 6,

        rotationAngle = 90,

        rotationAngle2 = 5; // rand(+-x)

    LSystemState currentState(QVector2D(mapSize.width() / 2, mapSize.height() / 2),

                              tmpVec.normalized(),

                              drawLength);

    QString currentWord = conf.system.sInitialWord;

    RoadJunctionPoint *rjp = new RoadJunctionPoint(currentState.position);

    junctions.push_back(rjp);

    for (int i = 0; i < conf.system.iIterations; ++i)

    {

        QString newWord = "";

        for (int j = 0; j < currentWord.length(); ++j)

        {

            if (conf.system.aRules.contains(currentWord.at(j)))

            {

                newWord += conf.system.aRules[currentWord.at(j)];

            }

            else

                newWord += currentWord.at(j);

        }

        currentWord = newWord;

    }

    for (int j = 0; j < currentWord.length(); ++j)

    {

        switch (currentWord.at(j).toAscii())

        {

        case 'X':

            currentState.drawLength = drawLength2;

            CreateRoad(rjp, currentState, inputImage);

            break;

        case 'F':

            currentState.drawLength = drawLength;

            CreateRoad(rjp, currentState, inputImage);

            break;

        case '+':

            currentState.direction = RotateVectorByAngle(currentState.direction, -rotationAngle);

            break;

        case '-':

            currentState.direction = RotateVectorByAngle(currentState.direction,  rotationAngle);

            break;

        case 'R':

            currentState.direction = RotateVectorByAngle(currentState.direction, (rand() % (rotationAngle2 * 2 + 1) - rotationAngle2) );

            break;

        case '[':

            aStack.push_back(currentState);

            break;

        case ']':

            currentState = aStack.last();

            aStack.pop_back();

            break;

        }

    }

    return junctions;

}

//-----//

void LSystemGenerator::CreateRoad(RoadJunctionPoint *rjp, LSystemState &state, const QImage *map)

{

    int heightAngles[] = { -30, -22, -15, -8, 0, 8, 15, 22, 30 };

    //int heightAngles[] = { 0 };

    int num = 9;

    Road *r;

    Road *lowestSlopeRoad = NULL;

    int slope = INT_MAX;

    for (int i = 0; i < num; ++i)

    {

        QVector2D rotation = RotateVectorByAngle(state.direction, heightAngles[i]);

        QVector2D newPosition =

            Clamp(QVector2D(state.position.x() + state.drawLength * rotation.x(),

                            state.position.y() + state.drawLength * rotation.y()),

                  map->size());

        r = new Road(state.position, newPosition);

        if (ValidPoint(map, newPosition) && r->Valid(map))

        {

            int heightDiff = abs(qRed(map->pixel(state.position.toPoint())) - qRed(map->pixel(newPosition.toPoint())));

            if (heightDiff < slope)

            {

                slope = heightDiff;

                if (lowestSlopeRoad)

                    delete lowestSlopeRoad;

                lowestSlopeRoad = r;

            }

            else

            {

                delete r;

            }

        }

        else

            delete r;

    }

    if (lowestSlopeRoad)

    {

        rjp->AddRoad(lowestSlopeRoad);

        state.position = lowestSlopeRoad->End();

    }

}

//-----//

bool LSystemGenerator::JunctionExists(const QVector2D &v) const

{

    unsigned num = 0;

    float epsilon = 2.0f;

    RoadJunctionPoint *rjp = junctions.first();

    //for (Utils::Junctions::const_iterator iter = junctions.begin(); iter != junctions.end(); ++iter)

    {

        for (Utils::Roads::const_iterator iter = rjp->StartingRoads().begin(); iter != rjp->StartingRoads().end(); ++iter)

        {

            QVector2D p1 = (*iter)->Start();

            QVector2D p2 = (*iter)->End();

            if ((fabs(p1.x() - v.x()) < epsilon && fabs(p1.y() - v.y()) < epsilon) ||

                (fabs(p2.x() - v.x()) < epsilon && fabs(p2.y() - v.y()) < epsilon))

            {

                ++num;

            }

        }

    }

    return num > 5;

}

//-----//

void LSystemGenerator::FilterRoads()

{

}

//-----//

QVector2D LSystemGenerator::RotateVectorByAngle(const QVector2D &vec, int angle)

{

    float tmpSin = sin((float)angle * M_PI / 180);

    float tmpCos = cos((float)angle * M_PI / 180);

    float tmpPosX = vec.x() * tmpCos - vec.y() * tmpSin;

    float tmpPosY = vec.x() * tmpSin + vec.y() * tmpCos;

    return QVector2D(tmpPosX, tmpPosY).normalized();

}

//-----//

QVector2D LSystemGenerator::Clamp(const QVector2D pt, const QSize &bounds) const

{

	return QVector2D(qBound(0.0, pt.x(), (qreal)bounds.width()),

					 qBound(0.0, pt.y(), (qreal)bounds.height()));

}

//-----//

bool LSystemGenerator::ValidPoint(const QImage *i, const QVector2D &p) const

{

    return i->rect().contains(p.toPoint()) &&

           qGray(i->pixel(p.toPoint())) > Utils::LEVEL_WATER

          ;//&& !JunctionExists(p);

}