itkSamplingScheme3D.h

Go to the documentation of this file.

#ifndef __itkSamplingScheme3D_h
#define __itkSamplingScheme3D_h


#include "itkVectorContainer.h"
#include "itkPoint.h"
#include "itkIntTypes.h"

#include "utl.h"


namespace itk
{

template< class TPixelType=double >
class ITK_EXPORT SamplingScheme3D : public VectorContainer<IdentifierType, Point< TPixelType, 3 > > 
{

public:

  typedef SamplingScheme3D             Self;
  typedef VectorContainer<IdentifierType, Point< TPixelType, 3 > >      Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(SamplingScheme3D, VectorContainer);

  typedef VectorContainer<IdentifierType, Point< TPixelType, 3 > >    PointsContainer;
  typedef Point<TPixelType, 3>            PointType;
  typedef TPixelType                      ValueType;

  typedef typename PointsContainer::Pointer         PointsContainerPointer;
  typedef typename PointsContainer::ConstPointer    PointsContainerConstPointer;

  typedef typename PointsContainer::ConstIterator    PointsContainerConstIterator;
  typedef typename PointsContainer::Iterator         PointsContainerIterator;

  typedef utl::NDArray<double,2>                     MatrixType;
  typedef utl_shared_ptr<MatrixType >                MatrixPointer;
  typedef std::vector<double>                        STDVectorType;
  typedef utl_shared_ptr<STDVectorType >             STDVectorPointer;
  typedef std::vector<int>                           IndexVectorType;
  typedef std::vector<IndexVectorType >              Index2DVectorType;
  typedef utl_shared_ptr<Index2DVectorType>          Index2DVectorPointer;
  
  MatrixPointer GetOrientationsCartesian(const bool alwarysReCalculate=false);
  MatrixPointer GetOrientationsSpherical(const bool alwarysReCalculate=false);
  void SetOrientationsCartesian(const MatrixPointer mat);
  void SetOrientationsSpherical(const MatrixPointer mat);
  MatrixPointer GetOrientationsCartesianInShell(const unsigned int shellIndex) const;
  MatrixPointer GetOrientationsSphericalInShell(const unsigned int shellIndex);
  

  void SetRadiusVector(const STDVectorPointer radiusVec);
  itkGetMacro(RadiusVector, STDVectorPointer);
  STDVectorPointer GetRadiusVectorInShell(unsigned int shellIndex);
  
  itkSetMacro(Tau, double);
  itkGetMacro(Tau, double);
  
  itkSetMacro(DeltaSmall, double);
  itkGetMacro(DeltaSmall, double);
  
  itkSetMacro(DeltaBig, double);
  itkGetMacro(DeltaBig, double);

  itkSetMacro(RadiusThresholdSingleShell, double);
  itkGetMacro(RadiusThresholdSingleShell, double);

  itkSetMacro(IndicesInShells, Index2DVectorPointer);
  itkGetMacro(IndicesInShells, Index2DVectorPointer);
  

  unsigned int GetNumberOfSamples() const
    {
    return this->Size();
    }
  unsigned int GetNumberOfSamplesInShell(const unsigned int shellIndex) const
    {
    if (shellIndex<m_IndicesInShells->size())
      return (*m_IndicesInShells)[shellIndex].size();
    else
      return 0;
    }
  unsigned int GetNumberOfShells() const
    {
    return m_IndicesInShells->size();
    }
  
  IndexVectorType GetNumberOfSamplesAtEachShell() const
    {
    IndexVectorType num;
    if (m_IndicesInShells->size()==0)
      {
      num.push_back(GetNumberOfSamples());
      return num;
      }
    for ( unsigned int i = 0; i < m_IndicesInShells->size(); i += 1 ) 
      num.push_back((*m_IndicesInShells)[i].size());
    return num;
    }
  
  void NormalizeDirections();
  
  void Clear();

  void RemoveSamplesNotIndexed();

  void GenerateFromRandomPoints(const std::vector<int>& numberOfPoints);

  void ReadOrientationFile(const std::string& gradFile, const int NoSymmetricDuple=DIRECTION_NODUPLICATE, 
      const int flipx=DIRECTION_NOFLIP, const int flipy=DIRECTION_NOFLIP, const int flipz=DIRECTION_NOFLIP, const bool need_normalize=true);
  
  void ReadOrientationFileList(const std::vector<std::string>& gradFileVec, const int NoSymmetricDuple=DIRECTION_NODUPLICATE, 
      const int flipx=DIRECTION_NOFLIP, const int flipy=DIRECTION_NOFLIP, const int flipz=DIRECTION_NOFLIP, const bool need_normalize=true);

  std::vector<STDVectorType> GroupRadiusValues();
  
  virtual void CorrectRadiusValues();

  void AppendOrientation(const double x, const double y, const double z, const int shell=-1);
  void AppendOrientation(const PointType& point, const int shell=-1);
  void AppendOrientationAndRadiusValue(const double x, const double y, const double z, const double radius, const int shell=-1);
  
  PointType GetOrientation(unsigned int index)
    {
    return this->GetElement(index);
    }
  double GetRadiusValue(unsigned int index)
    {
    return (*m_RadiusVector)[index];
    }
  
  MatrixPointer CalculateInnerProductMatrix(const bool isAbsolute=true) const;
  MatrixPointer CalculateElectrostaticEnergyMatrix(const double order=2.0) const;
  
  double CalculatePackingDensity( const bool isSymmetric=true) const;
  double CalculatePackingDensityInShell(const unsigned int shellIndex, const bool isSymmetric=true) const;
  
  double CalculateSphericalCodeEntropy( const bool isSymmetric=true) const;
  double CalculateSphericalCodeEntropyInShell(const unsigned int shellIndex, const bool isSymmetric=true) const;

  static double CalculateVoronoiEntropy(const MatrixType& grad, const MatrixType& gradTess, const bool isSymmetric=true);
  double CalculateVoronoiEntropy(const int tess=7, const bool isSymmetric=true);
  double CalculateVoronoiEntropyInShell(const unsigned int shellIndex, const int tess=7, const bool isSymmetric=true);
  
  double CalculateMaxDot(const unsigned int index, const bool isSymmetric=true) const;
  double CalculateMaxDotInShell(const unsigned int sampleIndex, const unsigned int shellIndex, const bool isSymmetric=true) const;

  double CalculateMinDistance(const unsigned int index, const bool isSymmetric=true) const;
  double CalculateMinDistanceInShell(const unsigned int sampleIndex, const unsigned int shellIndex, const bool isSymmetric=true) const;
  STDVectorType CalculateMinDistance(const bool isSymmetric=true) const;
  STDVectorType CalculateMinDistanceInShell(const unsigned int shellIndex, const bool isSymmetric=true) const;

  void GetNumbers(int& numberUniqueSamples, int& numberAntipodalSamples, int& numberRepeatedSamples ) const;

  double CalculateElectrostaticEnergy(const double order=2.0, const bool isNormalize=true, const bool countHalf=true ) const;
  double CalculateElectrostaticEnergyInShell(const unsigned int shellIndex, const double order=2.0, const bool isNormalize=true, const bool countHalf=true ) const;

  static double CalculateMinDistanceUpperBound(const unsigned int numberOfPoints, const bool isSphericalDistance=true);

protected:
  SamplingScheme3D();
  virtual ~SamplingScheme3D(){}
  
  typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;
 
  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;

  double m_Tau;
  
  double m_DeltaSmall;
  
  double m_DeltaBig;

  STDVectorPointer m_RadiusVector;

  Index2DVectorPointer m_IndicesInShells;

  double m_RadiusThresholdSingleShell;
  
  MatrixPointer m_OrientationsCartesian;
  MatrixPointer m_OrientationsSpherical;
 
private:
  SamplingScheme3D(const Self &); //purposely not implemented
  void operator=(const Self &);  //purposely not implemented

  void InsertElement(IdentifierType, PointType);  //purposely not implemented
  void SetElement(IdentifierType, PointType); //purposely not implemented
  PointType & CreateElementAt(IdentifierType); //purposely not implemented
};

}

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkSamplingScheme3D_hxx)
#include "itkSamplingScheme3D.hxx"
#endif

#endif