attributes.cpp

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * DEPRECATED - replaced by elbeem API, only channels are still used
 *
 *****************************************************************************/

#include "attributes.h"
#include "ntl_matrices.h"
#include "elbeem.h"



/******************************************************************************
 * attribute conversion functions
 *****************************************************************************/

bool Attribute::initChannel(int elemSize) {
        elemSize=0; // remove warning
        return false;
}
string Attribute::getAsString(bool debug) {
        debug=false; // remove warning
        return string("");
}
int Attribute::getAsInt() {
        return 0;
}
bool Attribute::getAsBool() {
        return false;
}
double Attribute::getAsFloat() {
        return 0.;
}
ntlVec3d Attribute::getAsVec3d() {
        return ntlVec3d(0.);
}
void Attribute::getAsMat4Gfx(ntlMat4Gfx *mat) {
        mat=NULL; // remove warning
}
string Attribute::getCompleteString() {
        return string("");
}


/******************************************************************************
 * channel returns
 *****************************************************************************/

AnimChannel<double> Attribute::getChannelFloat() {
        return AnimChannel<double>();
}
AnimChannel<int> Attribute::getChannelInt() { 
        return AnimChannel<int>();
}
AnimChannel<ntlVec3d> Attribute::getChannelVec3d() { 
        return AnimChannel<ntlVec3d>();
}
AnimChannel<ntlSetVec3f> 
Attribute::getChannelSetVec3f() {
        return AnimChannel<ntlSetVec3f>();
}

/******************************************************************************
 * check if there were unknown params
 *****************************************************************************/
bool AttributeList::checkUnusedParams() {
        return false;
}
void AttributeList::setAllUsed() {
}

/******************************************************************************
 * Attribute list read functions
 *****************************************************************************/
int AttributeList::readInt(string name, int defaultValue, string source,string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return defaultValue;
}
bool AttributeList::readBool(string name, bool defaultValue, string source,string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return defaultValue;
}
double AttributeList::readFloat(string name, double defaultValue, string source,string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return defaultValue;
}
string AttributeList::readString(string name, string defaultValue, string source,string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return defaultValue;
}
ntlVec3d AttributeList::readVec3d(string name, ntlVec3d defaultValue, string source,string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return defaultValue;
}

void AttributeList::readMat4Gfx(string name, ntlMat4Gfx defaultValue, string source,string target, bool needed, ntlMat4Gfx *mat) {
        *mat = defaultValue;
        name=source=target=string(""); needed=false; mat=NULL; // remove warning
}

// set that a parameter can be given, and will be ignored...
bool AttributeList::ignoreParameter(string name, string source) {
        name = source = ("");
        return false;
}
                
// read channels
AnimChannel<int> AttributeList::readChannelInt(string name, int defaultValue, string source, string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<int>(defaultValue);
}
AnimChannel<double> AttributeList::readChannelFloat(string name, double defaultValue, string source, string target, bool needed ) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<double>(defaultValue);
}
AnimChannel<ntlVec3d> AttributeList::readChannelVec3d(string name, ntlVec3d defaultValue, string source, string target, bool needed ) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<ntlVec3d>(defaultValue);
}
AnimChannel<ntlSetVec3f> AttributeList::readChannelSetVec3f(string name, ntlSetVec3f defaultValue, string source, string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<ntlSetVec3f>(defaultValue);
}
AnimChannel<float> AttributeList::readChannelSinglePrecFloat(string name, float defaultValue, string source, string target, bool needed ) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<float>(defaultValue);
}
AnimChannel<ntlVec3f> AttributeList::readChannelVec3f(string name, ntlVec3f defaultValue, string source, string target, bool needed) {
        name=source=target=string(""); needed=false; // remove warning
        return AnimChannel<ntlVec3f>(defaultValue);
}

/******************************************************************************
 * destructor
 *****************************************************************************/
AttributeList::~AttributeList() { 
};


/******************************************************************************
 * debugging
 *****************************************************************************/

void Attribute::print() {
}
                
void AttributeList::print() {
}


/******************************************************************************
 * import attributes from other attribute list
 *****************************************************************************/
void AttributeList::import(AttributeList *oal) {
        oal=NULL; // remove warning
}


/******************************************************************************
 * channel max finding
 *****************************************************************************/
ntlVec3f channelFindMaxVf (AnimChannel<ntlVec3f> channel) {
        ntlVec3f ret(0.0);
        float maxLen = 0.0;
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                float nlen = normNoSqrt(channel.accessValues()[i]);
                if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
        }
        return ret;
}
ntlVec3d channelFindMaxVd (AnimChannel<ntlVec3d> channel) {
        ntlVec3d ret(0.0);
        float maxLen = 0.0;
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                float nlen = normNoSqrt(channel.accessValues()[i]);
                if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
        }
        return ret;
}
int      channelFindMaxi  (AnimChannel<float   > channel) {
        int ret = 0;
        float maxLen = 0.0;
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                float nlen = ABS(channel.accessValues()[i]);
                if(nlen>maxLen) { ret= (int)channel.accessValues()[i]; maxLen=nlen; }
        }
        return ret;
}
float    channelFindMaxf  (AnimChannel<float   > channel) {
        float ret = 0.0;
        float maxLen = 0.0;
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                float nlen = ABS(channel.accessValues()[i]);
                if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
        }
        return ret;
}
double   channelFindMaxd  (AnimChannel<double  > channel) {
        double ret = 0.0;
        float maxLen = 0.0;
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                float nlen = ABS(channel.accessValues()[i]);
                if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
        }
        return ret;
}

/******************************************************************************
 // unoptimized channel simplification functions, use elbeem.cpp functions
 // warning - currently only with single precision
 *****************************************************************************/

template<class SCALAR>
static bool channelSimplifyScalarT(AnimChannel<SCALAR> &channel) {
        int   size = channel.getSize();
        if(size<=1) return false;
        float *nchannel = new float[2*size];
        // convert to array
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                nchannel[i*2 + 0] = (float)channel.accessValues()[i];
                nchannel[i*2 + 1] = (float)channel.accessTimes()[i];
        }
        bool ret = elbeemSimplifyChannelFloat(nchannel, &size);
        if(ret) {
                vector<SCALAR> vals;
                vector<double> times;
                for(int i=0; i<size; i++) {
                        vals.push_back(  (SCALAR)(nchannel[i*2 + 0]) );
                        times.push_back( (double)(nchannel[i*2 + 1]) );
                }
                channel = AnimChannel<SCALAR>(vals, times);
        }
        delete [] nchannel;
        return ret;
}
bool channelSimplifyi  (AnimChannel<int   > &channel) { return channelSimplifyScalarT<int>(channel); }
bool channelSimplifyf  (AnimChannel<float> &channel) { return channelSimplifyScalarT<float>(channel); }
bool channelSimplifyd  (AnimChannel<double  > &channel) { return channelSimplifyScalarT<double>(channel); }
template<class VEC>
static bool channelSimplifyVecT(AnimChannel<VEC> &channel) {
        int   size = channel.getSize();
        if(size<=1) return false;
        float *nchannel = new float[4*size];
        // convert to array
        for(size_t i=0; i<channel.accessValues().size(); i++) {
                nchannel[i*4 + 0] = (float)channel.accessValues()[i][0];
                nchannel[i*4 + 1] = (float)channel.accessValues()[i][1];
                nchannel[i*4 + 2] = (float)channel.accessValues()[i][2];
                nchannel[i*4 + 3] = (float)channel.accessTimes()[i];
        }
        bool ret = elbeemSimplifyChannelVec3(nchannel, &size);
        if(ret) {
                vector<VEC> vals;
                vector<double> times;
                for(int i=0; i<size; i++) {
                        vals.push_back(  VEC(nchannel[i*4 + 0], nchannel[i*4 + 1], nchannel[i*4 + 2] ) );
                        times.push_back( (double)(nchannel[i*4 + 3]) );
                }
                channel = AnimChannel<VEC>(vals, times);
        }
        delete [] nchannel;
        return ret;
}
bool channelSimplifyVf (AnimChannel<ntlVec3f> &channel) {
        return channelSimplifyVecT<ntlVec3f>(channel);
}
bool channelSimplifyVd (AnimChannel<ntlVec3d> &channel) {
        return channelSimplifyVecT<ntlVec3d>(channel);
}

template<class Scalar>
string AnimChannel<Scalar>::printChannel() {
        std::ostringstream ostr;
        ostr << " CHANNEL #"<<  mValue.size() <<" = { ";
        for(size_t i=0;i<mValue.size();i++) {
                ostr <<"'"<< mValue[i]<<"' ";
                ostr << "@"<<mTimes[i]<<"; ";
        }
        ostr << " } ";
        return ostr.str();
} // */

// is now in header file: debugPrintChannel() 
// hack to force instantiation
void __forceAnimChannelInstantiation() {
        AnimChannel< float > tmp1;
        AnimChannel< double > tmp2;
        AnimChannel< string > tmp3;
        AnimChannel< ntlVector3Dim<float> > tmp4;
        AnimChannel< ntlVector3Dim<double> > tmp5;
        tmp1.debugPrintChannel();
        tmp2.debugPrintChannel();
        tmp3.debugPrintChannel();
        tmp4.debugPrintChannel();
        tmp5.debugPrintChannel();
}


ntlSetVec3f::ntlSetVec3f(double v ) {
        mVerts.clear();
        mVerts.push_back( ntlVec3f(v) );
}
const ntlSetVec3f& 
ntlSetVec3f::operator=(double v ) {
        mVerts.clear();
        mVerts.push_back( ntlVec3f(v) );
        return *this;
}

std::ostream& operator<<( std::ostream& os, const ntlSetVec3f& vs ) {
        os<< "{";
        for(int j=0;j<(int)vs.mVerts.size();j++)  os<<vs.mVerts[j];
        os<< "}";
  return os;
}

ntlSetVec3f& 
ntlSetVec3f::operator+=( double v )
{
        for(int j=0;j<(int)(mVerts.size()) ;j++) {
                mVerts[j] += v;
        }
        return *this;
}

ntlSetVec3f& 
ntlSetVec3f::operator+=( const ntlSetVec3f &v )
{
        for(int j=0;j<(int)MIN(mVerts.size(),v.mVerts.size()) ;j++) {
                mVerts[j] += v.mVerts[j];
        }
        return *this;
}

ntlSetVec3f& 
ntlSetVec3f::operator*=( double v )
{
        for(int j=0;j<(int)(mVerts.size()) ;j++) {
                mVerts[j] *= v;
        }
        return *this;
}

ntlSetVec3f& 
ntlSetVec3f::operator*=( const ntlSetVec3f &v )
{
        for(int j=0;j<(int)MIN(mVerts.size(),v.mVerts.size()) ;j++) {
                mVerts[j] *= v.mVerts[j];
        }
        return *this;
}