mlClusterInfo.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
**
**************************************************************************************/
 
#ifndef ML_CLUSTER_INFO_H
#define ML_CLUSTER_INFO_H
 
#include "MLClusterAlgorithmSystem.h"
 
#include <mlVector3.h>
 
ML_START_NAMESPACE

struct ClusterUserDataParameters
{
  ClusterUserDataParameters()
  {
    useImageValueAsUserData = false;
    voxelSizeInMilliliters = 0.001;
    backgroundValue = 0;
  }
  bool useImageValueAsUserData;
  MLdouble voxelSizeInMilliliters;
  MLdouble backgroundValue;
};

struct ClusterBoundingBox
{
  ClusterBoundingBox()
  {
    min.assign(ML_DOUBLE_MAX, ML_DOUBLE_MAX, ML_DOUBLE_MAX);
    max.assign(-ML_DOUBLE_MAX, -ML_DOUBLE_MAX, -ML_DOUBLE_MAX);
  }
 
  void addPosition(MLint x, MLint y, MLint z)
  {
    if (min[0] > x) { min[0] = static_cast<MLdouble>(x); }
    if (min[1] > y) { min[1] = static_cast<MLdouble>(y); }
    if (min[2] > z) { min[2] = static_cast<MLdouble>(z); }
 
    if (max[0] < x) { max[0] = static_cast<MLdouble>(x); }
    if (max[1] < y) { max[1] = static_cast<MLdouble>(y); }
    if (max[2] < z) { max[2] = static_cast<MLdouble>(z); }
  }
 
  Vector3 min;
  Vector3 max;
};

class ClusterInfo
{
public:

  ClusterInfo() :
    _indexId(0),
    _numVoxels(0),
    _rank(0),
    _userData(0),
    _imageValue(0)
  {
  }

  virtual ~ClusterInfo() {}


  ML_FORCE_INLINE MLuint getId() const { return _indexId; }


  ML_FORCE_INLINE MLuint numVoxels() const { return _numVoxels; }


  ML_FORCE_INLINE MLuint rank() const { return _rank; }

  ML_FORCE_INLINE MLdouble userData() const { return _userData; }
  ML_FORCE_INLINE void setUserData(MLdouble userData) { _userData = userData; }

  ML_FORCE_INLINE MLdouble imageValue() const { return _imageValue; }
  ML_FORCE_INLINE void setImageValue(MLdouble imageValue) { _imageValue = imageValue; }

  ML_FORCE_INLINE void addPositionToBoundingBox(MLint x, MLint y, MLint z) { _boundingBox.addPosition(x, y, z); }
  ML_FORCE_INLINE Vector3 getBoundingBoxMin() const { return _boundingBox.min; }
  ML_FORCE_INLINE Vector3 getBoundingBoxMax() const { return _boundingBox.max; }
 
 
protected:

  MLuint _indexId;

  MLuint _numVoxels;


  MLuint _rank;

  MLdouble _userData;

  MLdouble _imageValue;
 
  ClusterBoundingBox _boundingBox;
};
 
 

struct less
{
  ML_FORCE_INLINE bool operator() (const ClusterInfo& x, const ClusterInfo& y)
  {
    if (x.numVoxels() > y.numVoxels())
    {
      return true;
    }
    if (x.numVoxels() < y.numVoxels())
    {
      return false;
    }
    return (x.getId() < y.getId());
  }
};
 
 
ML_END_NAMESPACE
 
#endif