C:/Projekte/C++/FlowVIS_107/src/FlowChannel.cpp

Go to the documentation of this file.

#include "FlowChannel.h"
#include <math.h>


void FlowChannel::moveMinimumToZero()
{
  // gv Move minimum to origin

  if ( minimum != 0.0 ) 
  {
    for( int i=0; i<geom->getDimX()*geom->getDimY(); i++ )
      values[i] = values[i] - minimum;

    maximum = maximum - minimum;
    minimum = 0;
  }

/*
  // gv TEST: search for min-value
  float testMin = maximum;
  for( int i=0; i<geom->getDimX()*geom->getDimY(); i++ )
  {
    if ( values[i] < testMin ) testMin = values[i];
  }

  std::cout << "found min: " << testMin << std::endl;
*/
}


float FlowChannel::getValue(vec3 pos)
{
    //IDs of cell vertices
    int vtxID[4];
    //weighting coefficients for interpolation
    float coef[4];
    
    //let's determine the neighbouring geometry and get the interpolation coefficients
    //this is a general scheme... there can be various interpolation schemes used (nearest, linear) inside of the getInterpolationAt
    if (geom->getInterpolationAt_old(pos, vtxID, coef))
        return values[vtxID[0]]*coef[0] + values[vtxID[1]]*coef[1] + values[vtxID[2]]*coef[2] + values[vtxID[3]]*coef[3];
    else
    {
        std::cerr << "Outside of the dataset" << std::endl;
        return 0;
    }
}


float* FlowChannel::getData() const
{
  return values;
}

float FlowChannel::getValue(int vtxID)
{
    return values[vtxID];
}

float FlowChannel::getValueNormPos(vec3 pos)
{
        //first scale the coordinates back
    vec3 realPos = geom->unNormalizeCoords(pos);
        //now make a lookup
    return getValue(realPos);
}

float FlowChannel::getValueNormPos(float x, float y)
{
        //calls the previous method
    return getValueNormPos(vec3(x,y));
}

float FlowChannel::normalizeValue(float val)
{
  //scales the value so that minimum would be 0 and maximum 1
  return (val - minimum) / (maximum - minimum); 
}

FlowChannel::FlowChannel(FlowGeometry* g)
{
    geom = g;

    //create the appropriate storage
    values = new float[ geom->getDimX() * geom->getDimY() ];

    minimum = (float) HUGE_VAL;
    maximum = (float) -HUGE_VAL;

    //std::cout << "ok" << std::endl;    
}

FlowChannel::~FlowChannel()
{
        //delete the value storage
    delete[] values;
    std::cout << "ok" << std::endl;
}

void FlowChannel::setValue(int vtxID, float val)
{
    values[vtxID] = val;
        //update the minimum and maximum
    minimum = (val < minimum) ? val : minimum;
    maximum = (val > maximum) ? val : maximum;    
}

void FlowChannel::copyValues( float* rawdata, int vtxSize, int offset )
{
  for ( int i=0; i<geom->getDimX() * geom->getDimY(); i++ )
  {
    values[i] = rawdata[ (i * vtxSize) + offset ];

    //update the minimum and maximum
    minimum = (values[i] < minimum) ? values[i] : minimum;
    maximum = (values[i] > maximum) ? values[i] : maximum;
  }

  /*
  std::cout << " - Maximum value in channel: " << maximum << std::endl;
  std::cout << " - Minimum value in channel: " << minimum << std::endl;    
  */
}


// gv Simply copy the values from the rawData to the channel
void FlowChannel::copyValues( float* rawData )
{
  for ( int i=0; i<geom->getDimX() * geom->getDimY(); i++ )
  {
    values[i] = rawData[i];

    //update the minimum and maximum
    minimum = (values[i] < minimum) ? values[i] : minimum;
    maximum = (values[i] > maximum) ? values[i] : maximum;
  }

  /*
  std::cout << " - Maximum value in channel: " << maximum << std::endl;
  std::cout << " - Minimum value in channel: " << minimum << std::endl;    
  */
}


void FlowChannel::setMax(float val)
{
  maximum = val;
}

void FlowChannel::setMin(float val)
{
 minimum = val;
}

float FlowChannel::getMin()
{
    return minimum;
}

float FlowChannel::getMax()
{
    return maximum;
}

float FlowChannel::getRange()
{
    return maximum - minimum;
}

---