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

Go to the documentation of this file.

#include "StreamLineGrid.h"

// needed for writing log-file
#include <iostream>
#include <fstream>


StreamLineGrid::StreamLineGrid( float dSep )
{
  //cout << "Create new SL-grid..." << endl;

  m_cellSize = dSep;
  m_dim = (int) ceil( (float)( 1.0f/m_cellSize ) );
  m_grid = new slgGridCell[ m_dim*m_dim ];
}


StreamLineGrid::~StreamLineGrid()
{
  delete [] m_grid;
}


bool StreamLineGrid::addPoint( vec3 point )
{
  // calculate cell-index
  int cellIdx = getCellIndex( point );

  // add point to cell
  if ( cellIdx >= 0 ) 
  {
    m_grid[ cellIdx ].points.push_back( point );

    //cout << "Added point " << point << " to cell " << cellIdx << endl;
    //cout << "Number of points in this cell: " << m_grid[ cellIdx ].points.size() << endl;

    return true;
  }
  else 
    // invalid index
    return false;
}


slgGridCell* StreamLineGrid::getSurroundingCells( vec3 point )
{
  int numNeighbors = NUM_NEIGHBORS;
  slgGridCell *neighborCells = new slgGridCell[ numNeighbors*numNeighbors ];

  // get index of lower-left cell
  int cellIdxX = getCellIndexX( point ) - 1;
  int cellIdxY = getCellIndexY( point ) - 1;

  // fetch points from grid
  for ( int i=0; i<(numNeighbors*numNeighbors); i++ )
  {
    // calculate new cell index
    int cIdxX = cellIdxX + ( i % numNeighbors );
    int cIdxY = (i < numNeighbors) ? (cellIdxY) : ( ( i < (2*numNeighbors) ) ? (cellIdxY+1) : (cellIdxY+2) );

    // add cell
    neighborCells[ i ] = getCell( getCellIndex( cIdxX, cIdxY ) );
  } // for 

  return neighborCells;
}


float StreamLineGrid::getMinimalDistance( vec3 point, vec3 exceptionPoint )
{
  int numNeighbors = NUM_NEIGHBORS;
  slgGridCell *neighborCells = getSurroundingCells( point );

  bool useExceptionPoint = true;

  if ( exceptionPoint[X]==-1 && exceptionPoint[Y]==-1 && exceptionPoint[Z]==-1 ) useExceptionPoint = false;

  //cout << "excPt(" << exceptionPoint << "), use? " << useExceptionPoint << "\n";

  float minDist = 1.1f; // set to maximum distance

  // calculate min distance
  for ( int i=0; i<(numNeighbors*numNeighbors); i++ )
  {
    int nrPts = (int)neighborCells[i].points.size();

    if ( nrPts > 0 ) 
    {
      for ( int j=0; j<nrPts; j++ )
      {
        // calculate dist to every point
        vec3 dPoint = neighborCells[i].points.at(j);

        if ( useExceptionPoint && (dPoint == exceptionPoint) ) 
        {
          // skip this point
          //cout << "skipping exceptionPoint\n";
        }
        else
        {
          float dist = point.dist( dPoint );
          if ( dist < minDist ) 
          {
            minDist = dist;
            //cout << "new minDist: " << minDist << "\n";
          }
        }

      } // for every point
    }

  } // for all neighbor-cells

  return (minDist <= 1.0) ? minDist : -1;
}


/*
bool StreamLineGrid::isValidPoint( vec3 point )
{
  // dummy
  return false;
}
*/

slgGridCell StreamLineGrid::getCell( int cellIdx )
{
  if ( cellIdx < 0 )
  {
    slgGridCell gc; 
    gc.points.clear();

    return gc;
  }
  else
    return m_grid[ cellIdx ];
}

/*
vector<vec3> StreamLineGrid::getCellPoints( int cellIdx )
{
  return m_grid[ cellIdx ].points;
}
*/

int StreamLineGrid::getCellIndexX( vec3 point )
{
  return (int)floor( point[X] / m_cellSize );
}


int StreamLineGrid::getCellIndexY( vec3 point )
{
  return (int)floor( point[Y] / m_cellSize );
}


int StreamLineGrid::getCellIndex( vec3 point )
{
  int idxX = getCellIndexX( point );
  int idxY = getCellIndexY( point );

  return getCellIndex( idxX, idxY );
}


int StreamLineGrid::getCellIndex( int idxX, int idxY )
{
  if ( idxX < 0      ||
       idxY < 0      ||
       idxX >= m_dim ||
       idxY >= m_dim 
     )
    // invalid index
    return -1;

  return idxX + idxY * m_dim;
}



void StreamLineGrid::printGrid()
{
  cout << "Writing the grids attached points to log-file (this may take a while - please be patient!) ... ";

  ofstream gridPointsLogFile;

  gridPointsLogFile.open ("slGrid_points.log");
  gridPointsLogFile << "Grid with Points in m_grid:\n\nIdx:\n";


  // for all grid-cells
  for ( int i=0; i<m_dim*m_dim; i++ )
  {
    gridPointsLogFile << i << ":\n";

    int nrPts = (int)m_grid[i].points.size();
    if ( nrPts > 0 )
    {
      // for all points attached to cell
      for ( int j=0; j<nrPts; j++ )
      {
        gridPointsLogFile << "  > " << m_grid[i].points.at( j ) << "\n";
      }
    }
    else 
      gridPointsLogFile << "  > empty\n";
  }


  gridPointsLogFile.close();
  cout << " done. " << endl;
}

---