*** empty log message ***

[lsystem3d.git] / src / lindenmayersystem.cpp

// Copyright (C) 2006 Erik Dahlberg
// 
// This file is part of LSystem3d.
// 
// LSystem3D is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// LSystem3D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with LSystem3D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA




#include <cmath>

#include <map>
#include <string>

#include "lindenmayersystem.h"
#include "model.h"
#include "turtle.h"



/**
 * Constructor
 * @param model empty model
 */
LindenmayerSystem::LindenmayerSystem(Model *model)
{
    _model = model;
    _turtle = new Turtle(model);
    
    clear();
}



/**
 * Destructor
 */
LindenmayerSystem::~LindenmayerSystem()
{
    delete _turtle;
}



/**
 * Clear all parameters
 */
void LindenmayerSystem::clear()
{
    _axiom.clear();
    _rules.clear();
    _turtle->setAngle(0.0);
    _numIterations = 0;
    
    _turtle->reset();
    _model->clear();
}



/**
 * Generate L-system data
 */
void LindenmayerSystem::generate()
{
    // model session
    _model->begin();
        _model->setColorIndex(0);
        recursiveWalk(_axiom, _numIterations);
    _model->end();
}



/**
 * Set the initial rule (the axiom)
 * @param axiom the axiom
 */
void LindenmayerSystem::setAxiom(string axiom)
{
    _axiom = verifyAndPreprocessRule(axiom);
}



/**
 * Set one rule
 * @param name rule name
 * @param rule the rule
 */
void LindenmayerSystem::setRule(string name, string rule)
{
    _rules[name] = verifyAndPreprocessRule(rule);
}



/**
 * Set the turn/pitch/roll angle
 * @param degrees the angle, in degrees
 */
void LindenmayerSystem::setAngle(double degrees)
{
    // convert from degrees to radians
    double radians = (degrees / 360.0) * (2.0 * M_PIl);
    
    _turtle->setAngle(radians);
}



/**
 * Set the number of iterations
 * @param numIterations number of iterations
 */
void LindenmayerSystem::setNumIterations(int numIterations)
{
    _numIterations = numIterations;
}



/**
 * Set diameter of segment
 * @param diameter the diameter
 */
void LindenmayerSystem::setDiameter(double diameter)
{
    _model->setDiameter(diameter);
}



/**
 * Set diameter factor
 * @param diameterFactor the diameter factor
 */
void LindenmayerSystem::setDiameterFactor(double diameterFactor)
{
    _model->setDiameterFactor(diameterFactor);
}



/**
 * Get the initial rule (the axiom)
 * @return the axiom
 */
string LindenmayerSystem::getAxiom()
{
    return unpreprocessRule(_axiom);
}



/**
 * Get all rules
 * @return the rules
 */
map<string,string> LindenmayerSystem::getRules()
{
    map<string,string> theUnpreprocessedRules;

    // unpreprocess all rules
    map<string,string>::iterator currentRule;
    for (currentRule = _rules.begin(); currentRule != _rules.end(); currentRule++)
    {
        theUnpreprocessedRules[currentRule->first] = unpreprocessRule(currentRule->second);
    }
    
    return theUnpreprocessedRules;
}



/**
 * Get the turn/pitch/roll angle
 * @return the angle, in degrees
 */
double LindenmayerSystem::getAngle()
{
    double radians = _turtle->getAngle();
    
    // convert from radians to degrees
    double degrees = 360.0 * (radians / (2.0 * M_PIl));
    
    return degrees;
}



/**
 * Get the number of iterations
 * @return number of iterations
 */
int LindenmayerSystem::getNumIterations()
{
    return _numIterations;
}



/**
 * Get the generated model
 * @return generated model
 */
Model *LindenmayerSystem::getModel()
{
    return _model;
}



/**
 * Recursively apply the replacement rules
 * @param rule rule
 * @param level recursion level
 */
void LindenmayerSystem::recursiveWalk(string rule, int level)
{
    // process every element in the rule string
    for (int i = 0; i < rule.size(); i++)
    {
        switch (rule[i])
        {
            // rule
            case '@':

                // ignore marker, i.e. the "@"
                i++;
                
                // recursion
                if (level > 0)
                {
                    char ruleName[] = {rule[i], '\0'};
                    recursiveWalk(_rules[ruleName], level - 1);
                }
                    
                break;
                
                
            // walk / rule
            case 'F':
                
                // replacement rule for 'F'?
                if (_rules.count("F") != 0 && level > 0)
                {
                    recursiveWalk(_rules["F"], level - 1);
                }
                else
                {
                    // no rule for "F"
                    _turtle->walk();
                }
                                        
                break;
                
                
            // turn left
            case '+':
                
                _turtle->turnLeft();
                break;
                
                
            // turn right
            case '-':
                
                _turtle->turnRight();
                break;
                
                
            // pitch down
            case '&':
            
                _turtle->pitchDown();
                break;
                
                
            // pitch up
            case '^':
                
                _turtle->pitchUp();
                break;
                
                
            // roll left
            case '\\':
                
                _turtle->rollLeft();
                break;
                
                
            // roll right
            case '/':
                    
                _turtle->rollRight();
                break;
                
                
            // turn around 180 degrees
            case '|':
                
                _turtle->turnAround();
                break;
                
                
            // save state to stack
            case '[':
                
                _turtle->push();
                break;
                
                
            // restore state from stack
            case ']':
                
                _turtle->pop();
                break;
                
                
            // create a filled surface
            case '{':
                
                _model->fillBegin();
                break;
                
                
            // close a filled surface
            case '}':
                
                _model->fillEnd();
                break;
                
                
            // one vertex in a filled surface
            case 'f':
                
                _turtle->fillWalk();
                break;
                
                
            // decrement diameter of segment
            case '!':
                
                _model->decrementDiameter();
                break;
                
                
            // increment current index to color table
            case '\'':
                
                _model->nextColor();
                break;
                
                
            // decrement current index to color table
            case ',':
                
                _model->prevColor();
                break;
        }
    }
}



/**
 * Verify and preprocess one rule string
 * @param rule the rule
 * @return the preprocessed rule
 */
string LindenmayerSystem::verifyAndPreprocessRule(string rule)
{
    // TODO: verifying
    
    string preprocessedRule;
    
    // check every element in rule
    for (int i = 0; i < rule.size(); i++)
    {
        // TODO: allow strings as names
        if (rule[i] >= 'A' && rule[i] <= 'Z' && rule[i] != 'F')
        {
            // add rule operator
            preprocessedRule += '@';
        }
        preprocessedRule += rule[i];
    }

    return preprocessedRule;
}



/**
 * Unpreprocess one rule string
 * @param rule the rule
 * @return the unpreprocessed rule
 */
string LindenmayerSystem::unpreprocessRule(string rule)
{
    string unpreprocessedRule;
    
    // check every element in rule
    for (int i = 0; i < rule.size(); i++)
    {
        // ignore rule operator
        if (rule[i] != '@')
        {
            unpreprocessedRule += rule[i];
        }
    }
    
    return unpreprocessedRule;
}