ComputeStrategy.h

Go to the documentation of this file.

#pragma once
#include <osg\Vec3>
#include <string>
#include <vector>
#include <osg\Referenced>

#include "Parameters.h"

namespace APDYNAMICART
{
//Interface

class IComputeStrategy : public osg::Referenced
{
public:
    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) = 0;
    virtual double getDefaultSize() = 0;
    virtual ~IComputeStrategy() {};

    virtual std::string const AttractorName() = 0;
};

typedef osg::ref_ptr<IComputeStrategy> IComputeStrategyPtr;

//Strategy classes

class NullStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Null"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3();
    }

    virtual double getDefaultSize() 
    {
        return 0.0;
    }
};

class LorenzStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Lorenz"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(x + params[0].value * params[3].value * (y - x),
                         y + params[3].value * (params[1].value * x - y - z*x),
                         z + params[3].value * (x*y - params[2].value * z));
    }

    virtual double getDefaultSize() 
    {
        return 0.5;
    }
};

class Lorenz84Strategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Lorenz84"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(x + params[4].value * (-params[0].value*x -y*y - z*z + params[0].value * params[2].value),
                         y + params[4].value * (-y + x*y -params[1].value*x*z + params[3].value),
                         z + params[4].value * (-z + params[1].value*x*y +x*z));
    }

    virtual double getDefaultSize() 
    {
        return 1.5;
    }

};

class PickoverStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Pickover"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(sin(params[0].value * y) - z * cos(params[1].value * x),
                         z * sin(params[2].value * x) - cos(params[3].value * y),
                         /*params[4].value * */ sin(x));
    }

    virtual double getDefaultSize() 
    {
        return 5.0;
    }

};

class RosslerStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Rossler"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(x - params[3].value * (y + z),
                         y + params[3].value * (params[1].value + (x*y) - (params[2].value*y)),
                         z + params[3].value * (x + (params[0].value*z)));
    }

    virtual double getDefaultSize() 
    {
        return 0.1;
    }

};

class PolynomialStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Polynomial"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(params[0].value + y - y*z,
                         params[1].value + z - x*z,
                         params[2].value + x - x*y);
    }

    virtual double getDefaultSize() 
    {
        return 1.0;
    }

};

class IkedaStrategy : public IComputeStrategy
{
    std::string const AttractorName() { return "Ikeda"; }

    virtual osg::Vec3 getNextPoint( double x, double y, double z, const Parameters& params ) 
    {
        return osg::Vec3(params[0].value + params[1].value * (x * cos(z) - y * sin(z)),
                         params[1].value * (x * sin(z) + y * cos(z)),
                         params[2].value - params[3].value / (1 + x * x + y * y));
    }

    virtual double getDefaultSize() 
    {
        return 2.5;
    }

};
}