Utils.h

Go to the documentation of this file.

#pragma once

#include <osg/io_utils>
#include "DATool.h"
#include "Spline.h"

namespace APDYNAMICART
{
class Utils;

typedef osg::ref_ptr<osg::UIntArray> UIntArrayPtr;
typedef osg::ref_ptr<osg::Vec3Array> Vec3ArrayPtr;
typedef osg::ref_ptr<osg::Vec4Array> Vec4ArrayPtr;
typedef osg::ref_ptr<osg::Geode> GeodePtr;
typedef osg::ref_ptr<osg::Geometry> GeometryPtr;

typedef osg::ref_ptr<vreckoUtils::Menu> MenuPtr;
typedef osg::ref_ptr<vreckoUtils::MenuRoot> MenuRootPtr;
typedef osg::ref_ptr<vreckoUtils::IMenuComponent> IMenuComponentPtr;

#define err(msg) \
    std::cerr << __FUNCTION__<< " - " << msg << std::endl;

#if 0
#define dbgAtt(msg) \
    std::cout << msg << std::endl;
#else
#define dbgAtt(msg) 
#endif

#if 1
#define dbgPS(msg) \
    std::cout << msg << std::endl;
#else
#define dbgPS(msg) 
#endif

class Stroke
{
public:
    virtual Vec3ArrayPtr getPositionSamples() const = 0;
    
    //TODO ask Martin - what about this
    virtual Vec4ArrayPtr getOrientationSamples() const = 0;
    
    virtual osg::ref_ptr<osg::DoubleArray> getTimeStamps() const = 0;
    virtual SplinePtr getLeadingSpline() const = 0;
};

template <class T>
class PoAAdapter : public osg::Referenced
{
public:
    virtual void createMenu(osg::ref_ptr<vreckoUtils::Menu> menu) {}

    virtual osg::ref_ptr<T> getObject() = 0;

    virtual bool itemClicked(const char* itemID)  { return false; }

    virtual int load( XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* ParametersNode ) { return 0; }

    virtual void pointed( bool pointed ) {}

    virtual void save(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode) {}


    virtual bool sliderChanged(const char* sliderID, float sliderPos) { return false; }
    virtual void update() {}

    virtual std::string classDescription() const = 0;

    virtual std::string className() const = 0;
protected:
    virtual ~PoAAdapter() {};
};

template <class T> 
class AdapterFactory
{
public:
    const std::vector<osg::ref_ptr<T> >& getSupportedAdapters() const { return _adapters; }

    osg::ref_ptr<T> getAdapter(const std::string& className)
    {
        for (u_int i = 0; i < this->_adapters.size(); ++i) 
        {
            if (this->_adapters[i]->className() == className)
                return this->_adapters[i];
        }
        return NULL;
    }

protected:
    std::vector<osg::ref_ptr<T> > _adapters;
};

class Utils
{   
public:
    static void interpolateVec3(osg::Vec3Array* controlPoints, osg::Vec3Array* interpolatedPoints, int p_steps);
    static osg::Vec3 interpolatePoint(double t, osg::Vec3 point1, osg::Vec3 point2, osg::Vec3 point0, osg::Vec3 point3);
    static bool isValueInsideRange( double value, double rangeStart, double rangeEnd );

    inline static DATool* createDATool( const std::string& toolName, vrecko::BaseClass* owner) {
        return static_cast<DATool*>(world->createAbility("DynamicArt", toolName, owner));
    }

    inline static void disableShaders(osg::StateSet* stateSet) {
        stateSet->setAttributeAndModes(new osg::Program());
    }
    static void setLayout(const std::string& name);


    // functions for splitting a string by defined delimiter
    static std::vector<std::string> &splitString(const std::string &s, char delim, std::vector<std::string> &elems) {
        std::stringstream ss(s);
        std::string item;
        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }
        return elems;
    }

    static std::vector<std::string> splitString(const std::string &s, char delim) {
        std::vector<std::string> elems;
        splitString(s, delim, elems);
        return elems;
    }

    static string convertInt(int number)
    {
        stringstream ss;//create a stringstream
        ss << number;//add number to the stream
        return ss.str();//return a string with the contents of the stream
    }

    static int convertString(string number)
    {
        istringstream is(number);
        int num;
        is >> num;
        return num;
    }


private:
    Utils() {};
};

struct Limits 
{
    double minX, minY, minZ;
    double maxX, maxY, maxZ;

    inline void reset() {
        minX = minY = minZ = INT_MAX;
        maxX = maxY = maxZ = INT_MIN;
    }

    inline void adjustLimits( const osg::Vec3& point ) {
        double x = point._v[0]; double y = point._v[1]; double z = point._v[2];

        if(x < minX) minX = x; if(x > maxX) maxX = x; //X-axis
        if(y < minY) minY = y; if(y > maxY) maxY = y; //Y-axis
        if(z < minZ) minZ = z; if(z > maxZ) maxZ = z; //Z-axis
    }

    inline double getVolume() {
        return (maxX - minX) * (maxY - minY) * (maxZ - minZ);
    }
};

typedef osg::ref_ptr<std::vector<osg::Vec4>> ColorList;

class colorGradient
{
public:
    osg::Vec4 getColor(double val);
    void addColor(osg::Vec4 color) { _colors.push_back(color); }

private:
    
    //TODO value range can be defined here somehow
    std::vector<osg::Vec4> _colors;
    
};

class PoAState
{
public:
    void saveState(ref_ptr_PoA poa) {
        _stateMap[poa] = PosRot(poa->getPosition(), poa->getRotation().getRotate());
    }
    void removeState(ref_ptr_PoA poa) {
        auto it = _stateMap.find(poa);
        if(it == _stateMap.end()) { err("State of given PoA wasn't found!"); return; }
        _stateMap.erase(it);
    }

    void restoreAllPoAStates() {
        for(auto it = _stateMap.begin(); it != _stateMap.end(); ++it)
        {
            if(it->first.valid()) {
                it->first->setPosition(it->second.first);
                it->first->setRotation(it->second.second);
            }
        }
    }

protected:
    typedef std::pair<osg::Vec3, osg::Quat> PosRot;
    typedef std::map<ref_ptr_PoA, PosRot> StateMap;
    
    StateMap _stateMap;
};


}