mitkRandomParcellationGenerator.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef mitkRandomParcellationGenerator_h
#define mitkRandomParcellationGenerator_h

#include<itkImage.h>

#include "mitkCommon.h"
#include "MitkConnectomicsExports.h"

// mitk
#include <mitkCostFunctionBase.h>
#include <mitkRegionVoxelCounter.h>

//Itk Iterators
#include <itkNeighborhoodIterator.h>
#include <itkImageRegionIterator.h>

#include <vector>

//To use pair
#include <utility>

namespace mitk
{

  template <typename TPixel, unsigned int VImageDimension>
  class RandomParcellationGenerator
  {
  public:
    typedef itk::Image< TPixel, VImageDimension > ImageType;

    //Set-Functions
    void SetImage(itk::Image<TPixel, VImageDimension> *);
    void SetNumberNodes(int inputNumberNodes);
    void SetVariablesForMerging(int givenSizeOfSmallestRegion, int desiredNumberOfParcels, int givenSizeOfSmallestRegionBeginning);
    void SetBoolsForMerging(bool mergingWithNumberParcels, bool mergingWithSmallestParcel, bool justMergeSmallParcels);

    //Main Functions

    void GetRandomSeedVoxels();
    void ParcelGrowthOverFaces();
    void FillOverEdgeOrVertex();
    void AllocateIsolatedVoxels();
    int MergeParcels();
    void SetAppropriateValues();
    void ShowSizeOfRegions();

  protected:
    //Sub-Functions
    std::vector<double> GetCenterOfMass( itk::ImageRegionIterator<ImageType> it_region, int valueOfRegion, bool getSizeOfRegions );
    double GetDistance( std::vector<double> centerOfMass, typename ImageType::IndexType indexNewVoxel);
    double GetDistanceVector( std::vector<double> centerOfMass, std::vector<double> indexNewVoxel);
    int SmallestValue (std::vector<int> distance);
    double SmallestValue (std::vector<double> distance);
    typename ImageType::RegionType ExtendedRegion(typename ImageType::RegionType chosenRegion, typename ImageType::IndexType indexChosenVoxel);
    typename ImageType::RegionType ExtendedRegionNotNeighbor(typename ImageType::RegionType chosenRegion, typename ImageType::RegionType smallestRegion);
    bool IsUnique (int number, std::vector<int> vec);
    void GetSizeOfRegions();

    typedef itk::ImageRegion<3> RegionType;
    //Start the algorithm ParcelGrowthOverFaces with m_OddRegions and transfer them to m_EvenRegions or m_InvalidRegions respectively
    std::vector<std::pair<RegionType, int> > m_EvenRegions;
    std::vector<std::pair<RegionType, int> > m_OddRegions;
    std::vector<std::pair<RegionType, int> > m_InvalidRegions;
    std::vector<int> m_SizeOfRegions;
    //For merging; regions that can't be merged any more
    std::vector<int> m_SizeOfFinishedRegions;

    ImageType * m_Image;
    int m_NumberNodes;
    int m_GivenSizeOfSmallestRegion;
    int m_DesiredNumberOfParcels;
    int m_GivenSizeOfSmallestRegionBeginning;
    bool m_MergingWithNumberParcels;
    bool m_MergingWithSmallestParcel;
    bool m_JustMergeSmallParcels;
  };
}

#include "mitkRandomParcellationGenerator.cpp"

#endif /*  mitkRandomParcellationGenerator_h */