mlSimilarVectorDirectionsClusterAlgorithm.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_SIMILAR_VECTOR_DIRECTIONS_CLUSTER_ALGORITHM_H
#define ML_SIMILAR_VECTOR_DIRECTIONS_CLUSTER_ALGORITHM_H
 
#include "mlClusterAlgorithm.h"
#include "mlClusterRefVolume.h"
#include "mlClusterRefCollection.h"
 
ML_START_NAMESPACE
 

class SimilarVectorDirectionsClusterAlgorithm : public ClusterAlgorithm<const void*, SimilarVectorDirectionsClusterAlgorithm>
{
public:

  typedef ClusterAlgorithm<const void*, SimilarVectorDirectionsClusterAlgorithm>::ClusterVoxelType SimilarVectorDirectionsClusterVoxelType;

  SimilarVectorDirectionsClusterAlgorithm(const ComputeClusterParameters& parameters, Clusters* clusters) :
    ClusterAlgorithm<SimilarVectorDirectionsClusterVoxelType, SimilarVectorDirectionsClusterAlgorithm>(parameters, clusters)
  {
  }
 
  MLErrorCode runClustering()
  {
    const MLDataType inputDataType = _parameters.contentImage->getDataType();
    const bool isFloatVector = isFloatVectorType(inputDataType);
 
    const size_t numVectorComponents = getNumVectorComponents(inputDataType);
 
    // Allow only vector images to be processed.
    MLErrorCode errorCode = (numVectorComponents == 0) ? ML_BAD_DATA_TYPE : ML_RESULT_OK;
 
    if (ML_RESULT_OK == errorCode)
    {
      _numVectorComponents = static_cast<int>(numVectorComponents);
      _isFloatVector = isFloatVector;
      errorCode = ClusterAlgorithm<const void*, SimilarVectorDirectionsClusterAlgorithm>::runClustering();
    }
    return errorCode;
  }

  ML_FORCE_INLINE static SimilarVectorDirectionsClusterVoxelType getVoxel(void* position)
  {
    return static_cast<SimilarVectorDirectionsClusterVoxelType*>(position);
  }
 
  ML_FORCE_INLINE static MLdouble getVoxelAsDouble(void*)
  {
    return 0;
  }

  ML_FORCE_INLINE double calcDotProduct(SimilarVectorDirectionsClusterVoxelType vec1Ptr,
                               SimilarVectorDirectionsClusterVoxelType vec2Ptr)
  {
    double result = 0.0;
 
    if (_isFloatVector)
    {
      const float* inFloat1Ptr = reinterpret_cast<const float*>(vec1Ptr);
      const float* inFloat2Ptr = reinterpret_cast<const float*>(vec2Ptr);
      for (size_t i = 0u; i < static_cast<std::size_t>(_numVectorComponents); ++i)
      {
        result += inFloat1Ptr[i] * inFloat2Ptr[i];
      }
    }
    else
    {
      const double* inDouble1Ptr = reinterpret_cast<const double*>(vec1Ptr);
      const double* inDouble2Ptr = reinterpret_cast<const double*>(vec2Ptr);
      for (size_t i = 0u; i < static_cast<std::size_t>(_numVectorComponents); ++i)
      {
        result += inDouble1Ptr[i] * inDouble2Ptr[i];
      }
    }
    return result;
  }

  ML_FORCE_INLINE bool isInTolerance(SimilarVectorDirectionsClusterVoxelType neighborValue,
                            SimilarVectorDirectionsClusterVoxelType currentValue)
  {
    double dotProduct = calcDotProduct(currentValue, neighborValue);
    return std::abs(dotProduct) > _parameters.similarityToleranceVectors;
  }
 
  ML_FORCE_INLINE static const void* convertBackgroundValue(MLdouble )
  {
    return nullptr;
  }
 
private:
 
  ML_FORCE_INLINE bool isFloatVectorType(MLDataType inputDataType)
  {
    return (inputDataType == MLDataTypeFromName("vecf2")) ||
      (inputDataType == MLDataTypeFromName("vecf3")) ||
      (inputDataType == MLDataTypeFromName("vecf4")) ||
      (inputDataType == MLDataTypeFromName("vecf5")) ||
      (inputDataType == MLDataTypeFromName("vecf6")) ||
      (inputDataType == MLDataTypeFromName("vecf7")) ||
      (inputDataType == MLDataTypeFromName("vecf8")) ||
      (inputDataType == MLDataTypeFromName("vecf9")) ||
      (inputDataType == MLDataTypeFromName("vecf10")) ||
      (inputDataType == MLDataTypeFromName("vecf16")) ||
      (inputDataType == MLDataTypeFromName("vecf32")) ||
      (inputDataType == MLDataTypeFromName("vecf64"));
  }
 
  ML_FORCE_INLINE size_t getNumVectorComponents(MLDataType inputDataType)
  {
    return (inputDataType == MLDataTypeFromName("vecf2") || inputDataType == MLDataTypeFromName("vec2")) ? static_cast<size_t>(2) :
      (inputDataType == MLDataTypeFromName("vecf3") || inputDataType == MLDataTypeFromName("vec3")) ? static_cast<size_t>(3) :
      (inputDataType == MLDataTypeFromName("vecf4") || inputDataType == MLDataTypeFromName("vec4")) ? static_cast<size_t>(4) :
      (inputDataType == MLDataTypeFromName("vecf5") || inputDataType == MLDataTypeFromName("vec5")) ? static_cast<size_t>(5) :
      (inputDataType == MLDataTypeFromName("vecf6") || inputDataType == MLDataTypeFromName("vec6")) ? static_cast<size_t>(6) :
      (inputDataType == MLDataTypeFromName("vecf7") || inputDataType == MLDataTypeFromName("vec7")) ? static_cast<size_t>(7) :
      (inputDataType == MLDataTypeFromName("vecf8") || inputDataType == MLDataTypeFromName("vec8")) ? static_cast<size_t>(8) :
      (inputDataType == MLDataTypeFromName("vecf9") || inputDataType == MLDataTypeFromName("vec9")) ? static_cast<size_t>(9) :
      (inputDataType == MLDataTypeFromName("vecf10") || inputDataType == MLDataTypeFromName("vec10")) ? static_cast<size_t>(10) :
      (inputDataType == MLDataTypeFromName("vecf16") || inputDataType == MLDataTypeFromName("vec16")) ? static_cast<size_t>(16) :
      (inputDataType == MLDataTypeFromName("vecf32") || inputDataType == MLDataTypeFromName("vec32")) ? static_cast<size_t>(32) :
      (inputDataType == MLDataTypeFromName("vecf64") || inputDataType == MLDataTypeFromName("vec64")) ? static_cast<size_t>(64) :
      static_cast<size_t>(0);
  }
 
  int  _numVectorComponents;
  bool _isFloatVector;
};
 
 
ML_END_NAMESPACE
 
 
#endif