MeVisLab/Standard/Sources/ML/MLCSO/CSOTools/CSOMarchingSquares.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __MarchingSquares_H
#define __MarchingSquares_H

#include "MLCSOIncludes.h"
#include "CSOMarchingSquaresCell.h"
#include "CSOFunction.h"

ML_START_NAMESPACE



class MLCSO_EXPORT CSOMarchingSquares
{

public:

  struct AmbiguousCell { 
    CSOMarchingSquaresCell::vecPoint2DIter start;  
    CSOMarchingSquaresCell::vecPoint2DIter end;    
    CSOMarchingSquaresCell                 cell;   

    AmbiguousCell() {} 
    AmbiguousCell(CSOMarchingSquaresCell::vecPoint2DIter s, CSOMarchingSquaresCell::vecPoint2DIter e, CSOMarchingSquaresCell c) : start(s), end(e), cell(c) {}
  };

  typedef std::map<int, AmbiguousCell> mapAmbigousCell;     
  typedef mapAmbigousCell::iterator    mapAmbigousCellIter; 

  typedef std::map<int, CSOMarchingSquaresCell>        mapCell;      
  typedef mapCell::iterator            mapCellIter;  

  CSOMarchingSquares();
  ~CSOMarchingSquares();

  
public:

  void reset();
  void setInterpolation(bool use);
  void setImage(float* image, int imgSizeX, int imgSizeY);
  void setFunction(CSOFunction* implicitFunction, const Matrix4& voxelToWorldMatrix, int startX, int startY, int imgSizeX, int imgSizeY, int voxelZPosition);
  
  void findIsoLine(int startPosX, int startPosY, float isoValue, bool takeShortestPath, CSOMarchingSquaresCell::vecPoint2D& positions);
  void findAllIsoLines(float isoValue, bool takeShortestPath, std::vector<CSOMarchingSquaresCell::vecPoint2D>& vecPositions);
  bool fillCSO(CSO* cso, CSOMarchingSquaresCell::vecPoint2D& positions, float posZ, PagedImage* pImg,
               bool useSmoothing, float smoothingFactor, int numSmoothPasses, int smoothRange, CSOSmoothingModes smoothingMode) const;
  
protected:

  void _findStartPosition(int& startX, int& startY);
  bool _findNearestIsoCell(int voxelPosX, int voxelPosY, CSOMarchingSquaresCell& cell);
  bool _findNearestIsoCell(int voxelPos[2], CSOMarchingSquaresCell& cell);
  void _trackIsoCell(CSOMarchingSquaresCell startCell, int fromDir, CSOMarchingSquaresCell::vecPoint2D& positions, mapCell* pVisitedCells = NULL);
  void _createCell(int topLeftVoxel[2], CSOMarchingSquaresCell& cell);
  int  _walkToCell(const CSOMarchingSquaresCell& fromCell, int fromDir, CSOMarchingSquaresCell& toCell);
  int _getPossibleEnterDirection(const CSOMarchingSquaresCell& cell) const;
  unsigned int  _getKey(const CSOMarchingSquaresCell& cell) const;
  unsigned int _getKey(int x, int y) const;
  
  float _getValueAt(int x, int y);
  
protected:

  float*      _image;
  int         _imageSizeX;
  int         _imageSizeY;
  
  int _startX;
  int _startY;
  
  float       _isoValue;
  CSOFunction* _function;
  int _voxelZPosition;
  Matrix4 _voxelToWorldMatrix;
  
  bool        _bInterpolatePoints;
  mapAmbigousCell _mapAmbiguities;
  
  std::map <int, double> _existingValues;
};


inline void CSOMarchingSquares::setImage(float* image, int imgSizeX, int imgSizeY)
{
  _image = image;
  _imageSizeX = imgSizeX;
  _imageSizeY = imgSizeY;
  _startX = 0;
  _startY = 0;
  
  _function = NULL;
  _voxelZPosition = 0; 
}


inline void CSOMarchingSquares::setFunction(CSOFunction* implicitFunction,
                                            const Matrix4& voxelToWorldMatrix,
                                            int startX, int startY,
                                            int imgSizeX, int imgSizeY, 
                                            int voxelZPosition)
{
  _image      = NULL;
  
  _imageSizeX = imgSizeX;
  _imageSizeY = imgSizeY;
  
  _startX = startX;
  _startY = startY;
  
  _function           = implicitFunction;
  _voxelToWorldMatrix = voxelToWorldMatrix;
  
  _voxelZPosition     = voxelZPosition;    
}


inline void CSOMarchingSquares::setInterpolation(bool useInterpolation)
{
  _bInterpolatePoints = useInterpolation;
}


inline unsigned int CSOMarchingSquares::_getKey(const CSOMarchingSquaresCell& cell) const
{
  return _getKey(cell._topLeftVoxel[0], cell._topLeftVoxel[1]);
}


inline unsigned int CSOMarchingSquares::_getKey(int x, int y) const
{
  return 1 + x-_startX + ((1 + y-_startY) * (_imageSizeX+_startX+1));
}


inline int CSOMarchingSquares::_getPossibleEnterDirection(const CSOMarchingSquaresCell& cell) const
{
  int fromDir = cell.getToDirection(1);
  if (0 == fromDir) {
    fromDir = cell.getToDirection(2);
    if (0 == fromDir) {
      fromDir = cell.getToDirection(4);
      if (0 == fromDir) {
        fromDir = cell.getToDirection(8);
      }
    }
  }
  return fromDir;
}



ML_END_NAMESPACE

#endif // __MarchingSquares_H