CSOMarchingSquares.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 

 
#pragma once
 
 
#include "MLCSOIncludes.h"
#include "CSOMarchingSquaresCell.h"
#include "CSOFunction.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <boost/unordered_map.hpp>
#include <ThirdPartyWarningsRestore.h>
 
#include <queue>
#include <set>
#include <array>
 
ML_START_NAMESPACE
 


class MLCSO_EXPORT CSOMarchingSquares
{
public:

  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);
 
  struct FillCSOParameters
  {
    CSO* cso;
    CSOMarchingSquaresCell::vecPoint2D positions;
    float posZ;
    PagedImage* pImg;
    bool useSmoothing;
    float smoothingFactor;
    int numSmoothPasses;
    int smoothRange;
    CSOSmoothingModes smoothingMode;
    bool shouldReduceCSOToOnlyOneSeedPoint;
  };

  bool fillCSO(FillCSOParameters& parameters);
 
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, const int initialFromDir, CSOMarchingSquaresCell::vecPoint2D& positions, std::vector<std::array<unsigned char, 2>>* cellsVisitedDirections = nullptr);
  void _createCell(int topLeftVoxel[2], CSOMarchingSquaresCell& cell);
  void _createCell(int topLeftVoxel[2], std::set<unsigned int>& cellsVisited, std::queue<CSOMarchingSquaresCell>& cellFront);
  void _createCell(int topLeftVoxel[2], CSOMarchingSquaresCell& cell, float values[4], char cellConfig);
  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);

  bool _isInImage(int x, int y) const;
 
protected:

  float* _image;
  int _imageSizeX;
  int _imageSizeY;

  int _startX;
  int _startY;

  float _isoValue;
  CSOFunction* _function;
  int _voxelZPosition;
  Matrix4 _voxelToWorldMatrix;

  bool _bInterpolatePoints;

  boost::unordered_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 = nullptr;
  _voxelZPosition = 0;
}

 
inline void CSOMarchingSquares::setFunction(CSOFunction* implicitFunction,
                                            const Matrix4& voxelToWorldMatrix,
                                            int startX, int startY,
                                            int imgSizeX, int imgSizeY,
                                            int voxelZPosition)
{
  _image      = nullptr;
 
  _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