PhaseSpace.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "PhaseSpace.h"
using namespace OpenCAL;

#include <OpenCAL/Vector3.h>
#include <OpenCAL/Quaternion.h>
using namespace OpenCAL::Utils;

using namespace std;


/******************************
* Constructors and destructor *
******************************/

PhaseSpace::PhaseSpace(unsigned int reserve)
: m_position(0)
{
    if(reserve > 0)
        m_values.reserve(reserve);
        //m_values.resize(size, 0.0f);
}

PhaseSpace::PhaseSpace(const float *values, unsigned int size)
: m_position(0)
{
    m_values.reserve(size);

    for(unsigned int i = 0; i < size; ++i)
        m_values[i] = values[i];
}

/*
PhaseSpace::PhaseSpace(const PhaseSpace &source)
{
    cout << "Copying a phasespace..." << endl;
    m_values = source.m_values;
}
*/

PhaseSpace::~PhaseSpace()
{
}


/************************
* Get and set functions *
************************/

void PhaseSpace::setValues(const float *values, unsigned int size)
{
    m_values.resize(size);

    for(unsigned int i = 0; i < size; ++i)
        m_values[i] = values[i];
}


/**************************
* Concatenation functions *
**************************/

void PhaseSpace::concat(const PhaseSpace &p)
{
    m_values.reserve(m_values.size() + p.getSize());

    m_values.insert(m_values.end(), p.m_values.begin(), p.m_values.end());
}

void PhaseSpace::concat(const Vector3 &v)
{
    m_values.reserve(m_values.size() + 3);

    m_values.push_back(v.getX());
    m_values.push_back(v.getY());
    m_values.push_back(v.getZ());
}

void PhaseSpace::concat(const Quaternion &q)
{
    m_values.reserve(m_values.size() + 4);

    m_values.push_back(q.getScalar());
    m_values.push_back(q.getVector().getX());
    m_values.push_back(q.getVector().getY());
    m_values.push_back(q.getVector().getZ());
}


/*********************
* Operator functions *
*********************/

void PhaseSpace::operator+=(const PhaseSpace &p)
{

    for(unsigned int i = 0; i < m_values.size(); ++i)
        m_values[i] += p[i];
}

PhaseSpace PhaseSpace::operator+(const PhaseSpace &p)
{

    PhaseSpace result(m_values.size());

    for(unsigned int i = 0; i < m_values.size(); ++i)
        result.concat(m_values[i] + p[i]);

    return result;
}

PhaseSpace PhaseSpace::operator*(float value)
{
    PhaseSpace result(m_values.size());

    for(unsigned int i = 0; i < m_values.size(); ++i)
        result.concat(m_values[i] * value);

    return result;
}


/*******************
* Friend functions *
*******************/

PhaseSpace OpenCAL::operator*(float value, const PhaseSpace &p)
{
    PhaseSpace result(p.getSize());

    for(unsigned int i = 0; i < p.getSize(); ++i)
        result.concat(value * p[i]);

    return result;
}


/******************
* Other functions *
******************/

void PhaseSpace::add(const PhaseSpace &p, float scale)
{
    for(unsigned int i = 0; i < m_values.size(); ++i)
        m_values[i] += scale * p[i];
}

---