mlComputeClusters.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2014, 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_COMPUTE_CLUSTERS_H
#define ML_COMPUTE_CLUSTERS_H
 
#include "MLClusterAlgorithmSystem.h"
 
#include "mlClusterAlgorithm.h"
#include "mlIdenticalIntensitiesClusterAlgorithm.h"
#include "mlSimilarIntensitiesClusterAlgorithm.h"
#include "mlSimilarVectorDirectionsClusterAlgorithm.h"
 
#include <mlModuleIncludes.h>
 
 
ML_START_NAMESPACE
 
class Clusters;
class ComputeClusters;

class TypedComputeClusters
{
public:
 
  TypedComputeClusters(ComputeClusters* computer, Clusters* clusters);
 
  MLErrorCode getErrorCode() const { return _errorCode; }
 
  template <class DataType> void process()
  {
    if (_parameters.contentImage)
    {
      switch (_parameters.clusterMode)
      {
      case CLUSTER_MODE_VectorDirections:
        {
          SimilarVectorDirectionsClusterAlgorithm algorithm(_parameters, _clusters);
          _errorCode = algorithm.runClustering();
        }
        break;
      case CLUSTER_MODE_IdenticalIntensities:
        {
          IdenticalIntensitiesClusterAlgorithm<DataType> algorithm(_parameters, _clusters);
          _errorCode = algorithm.runClustering();
        }
        break;
      case CLUSTER_MODE_SimilarIntensities:
        {
          SimilarIntensitiesClusterAlgorithm<DataType> algorithm(_parameters, _clusters);
          _errorCode = algorithm.runClustering();
        }
        break;
      case CLUSTER_MODE_COUNT:
      default:
        mlError("ComputeClusters::computeClusters", ML_BAD_PARAMETER);
        _errorCode = ML_BAD_PARAMETER;
      }
    }
  }
 
private:
  Clusters* _clusters;
  ComputeClusterParameters _parameters;
  MLErrorCode _errorCode;
};

class MLCLUSTERALGORITHM_EXPORT ComputeClusters
{
public:

  ComputeClusters();
 
  void setClusterMode(CLUSTER_MODE_TYPE clusterMode)                   { _parameters.clusterMode = clusterMode; }
  void setSimilarityToleranceIntensities(MLdouble similarityTolerance) { _parameters.similarityToleranceIntensities = similarityTolerance;  }
  void setSimilarityToleranceVectors(MLdouble similarityTolerance)     { _parameters.similarityToleranceVectors = similarityTolerance; }
  void setUseBackgroundValue(bool useBackgroundValue)                  { _parameters.useBackgroundValue = useBackgroundValue; }
  void setBackgroundValue(MLdouble backgroundValue)                    { _parameters.backgroundValue = backgroundValue; }
  void setNeighborhoodRelation(NBH_TYPE neighborhoodRelation)          { _parameters.neighborhoodRelation = neighborhoodRelation; }
  void setContentImage(PagedImage* contentImage)                       { _parameters.contentImage = contentImage; }
  void setMaskImage(PagedImage* maskImage)                             { _parameters.maskImage = maskImage; }
  void setUseImageValueAsUserData(bool useImageValueAsUserData)        { _parameters.useImageValueAsUserData = useImageValueAsUserData; }
  void setProgressCB(MLRequestProgressCB* cb, void* userData)          { _parameters.progressCB = cb; _parameters.progressCBUserData = userData; }
 
  void ensureClusterModeForImageDataType();

  MLErrorCode computeClusters(Clusters* clusters);
 
private:
 
  ComputeClusterParameters _parameters;
 
  friend class TypedComputeClusters;
};
 
ML_END_NAMESPACE
 
#endif // __mlComputeClusters_H