CSOMarchingSquaresCell.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 <array>
 
ML_START_NAMESPACE
 
class CSOMarchingSquares;
 
 
// A cell consists of four voxel values, thus there are 16 possible configurations
// describing which voxel value is greater or lower than the isovalue.
// The cell configuration is saved as a bit set such that Bit 0 is set if the upper left
// corner is above the isovalue. See below for the mapping of nth bit to voxel position:
//
//   1--------2         2^0     2^1
//   |        |
//   |        |
//   |        |
//   |        |
//   8--------4         2^3     2^2
 
 
class MLCSO_EXPORT CSOMarchingSquaresCell
{
 
public:
 
  enum Direction
  {
    NONE   = 0, 
    LEFT   = 1, 
    TOP    = 2, 
    RIGHT  = 4, 
    BOTTOM = 8  
  };
 
  typedef std::vector<Vector2>    vecPoint2D;     
  typedef vecPoint2D::iterator vecPoint2DIter; 
 
  friend class CSOMarchingSquares; 
 
  CSOMarchingSquaresCell();
  ~CSOMarchingSquaresCell();
 
public:
 
  void reset();
  void set(int topLeftVoxel[2], float values[4], float isoValue, char cellConfig = 0);
  bool isAmbiguous() const;
  inline bool isIsoCell() const { return isIsoCell(_cellConfig); }
  static inline bool isIsoCell(char cellConfig);
 
  int  getToDirection(int fromDir) const;
  bool addPoints(bool bIinterpolate, int fromDir, vecPoint2D& points, float xyOffset);
 
  static inline char calculateCellConfig(float isoValue, float values[4])
  {
    char config = (static_cast<unsigned char>(values[0] >= isoValue) << 0) |
                  (static_cast<unsigned char>(values[1] >= isoValue) << 1) |
                  (static_cast<unsigned char>(values[2] >= isoValue) << 2) |
                  (static_cast<unsigned char>(values[3] >= isoValue) << 3);
    return config;
  }
 
  static int oppositeDirection(int fromDir)
  {
    switch (fromDir)
    {
    case LEFT:
      return RIGHT;
    case TOP:
      return BOTTOM;
    case RIGHT:
      return LEFT;
    case BOTTOM:
      return TOP;
    default:
      return NONE;
    }
  }
 
  bool operator != (CSOMarchingSquaresCell& rkCell)
  {
    return ((_cellConfig != rkCell._cellConfig) ||
            (_topLeftVoxel[0] != rkCell._topLeftVoxel[0]) ||
            (_topLeftVoxel[1] != rkCell._topLeftVoxel[1]));
  }
 
private:
 
  bool _isCorner() const;
 
  int _getDirectionOppositeOfEdge() const;
 
  std::array<float, 2> _voxelsInDirection(int direction) const;
 
  static float interpolate(float valueA, float valueB, float interpolationValue);
 
protected:
 
  unsigned char _cellConfig;
  int          _topLeftVoxel[2];
  float        _values[4];
  float        _isoValue;
  bool _isBorderLeft;
  bool _isBorderRight;
  bool _isBorderTop;
  bool _isBorderBottom;
};
 
 
inline bool CSOMarchingSquaresCell::isAmbiguous() const
{
  return (_cellConfig == 5) || (_cellConfig == 10);
}
 
 
inline bool CSOMarchingSquaresCell::isIsoCell(char cellConfig)
{
  return (cellConfig != 0) && (cellConfig != 15);
}
 
 
ML_END_NAMESPACE