validationsamplegenerator.txx

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

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

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: ValidationSampleGenerator.txx,v $
Language:  C++
Date:      $Date: 2003-09-10 14:30:12 $
Version:   $Revision: 1.5 $

Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

This software is distributed WITHOUT ANY WARRANTY; without even 
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __ValidationSampleGenerator_txx
#define __ValidationSampleGenerator_txx

#include "ValidationSampleGenerator.h"
#include <time.h>

template< class TImage, class TClassMaskImage, class TVectorImage >
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::ValidationSampleGenerator()
{
  m_NumberOfMeasurements = PixelTraitsType::Dimension ;
  m_VectorImage = TVectorImage::New() ;
  m_Sample = ImageSampleType::New() ;
  m_Subsample = SubsampleType::New() ;
  m_Subsample->SetSample(m_Sample.GetPointer()) ;
  m_ClassMaskImageOffset = 0 ;
  m_UseSliceFiller = false ;
  m_Histogram = HistogramType::New() ;
  m_ClassMaskImageReader = ClassMaskImageReaderType::New() ;
  m_SliceFiller = SliceFiller< TClassMaskImage >::New() ;
  m_Importer = ImporterType::New() ;
  m_TreeGenerator = TreeGeneratorType::New() ;
  m_KdTreeBucketSize = 100 ;
}

template< class TImage, class TClassMaskImage, class TVectorImage >
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::~ValidationSampleGenerator()
{
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void 
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::SetImageFileNames(const std::vector< std::string >& fileNames)
{
  if ( fileNames.size() != m_NumberOfMeasurements )
    {
      std::cout 
        << "ERROR: the number of file names doesn't match "
        << "the VectorImage's vector length"<< std::endl ;
      return ;
    }

  m_ImageFileNames = fileNames ;
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::SetClassMaskImageFileName(const char* fileName, 
                            unsigned int defaultClassLabel,
                            int sliceOffset)
{
  m_ClassMaskImageFileName = fileName ;
  if ( sliceOffset != itk::NumericTraits< int >::min())
    {
      m_ClassMaskImageOffset = sliceOffset ;
      m_DefaultClassLabel = defaultClassLabel ;
      m_UseSliceFiller = true ;
    }
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::GenerateData()
{
  std::cout << "DEBUG: Loading the images..." << std::endl ;
  this->LoadImages() ;

  std::cout << "DEBUG: Loading the class mask image..." << std::endl ;
  this->LoadClassMaskImage()  ;

  std::cout << "DEBUG: Generating the vector image..." << std::endl ;
  this->GenerateVectorImage() ;

  if ( m_OutputNormalized )
    {
      std::cout << "DEBUG: Calculating the statistics of the images..." << std::endl ;
      this->CalculateImageStatistics() ;
      std::cout << "DEBUG: Normalizing the vector image..." << std::endl ;
      this->Normalize() ;
    }

  if ( m_OutputSampleType == VECTOR_IMAGE )
    {
      return ;
    }

  std::cout << "DEBUG: Generating the list sample..." << std::endl ;
  this->GenerateListSample() ;

  if ( m_OutputSampleType == LIST_SAMPLE )
    {
      return ;
    }

  if ( m_OutputSampleType == HISTOGRAM )
    {
      std::cout << "DEBUG: Generating the histogram..." << std::endl ;
      this->GenerateHistogram() ;
      return ;
    }

  if ( m_OutputSampleType == WEIGHTED_CENTROID_KD_TREE )
    {
      std::cout << "DEBUG: Generating the k-d tree..." << std::endl ;
      this->GenerateWeightedCentroidKdTree() ;
      return ;
    }
}

template< class TImage, class TClassMaskImage, class TVectorImage >
int
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::GetFileIndex(const char* fileName)
{
  for (unsigned int i = 0 ; i < m_ImageFileNames.size() ; i++)
    {
      if ( m_ImageFileNames[i] == fileName )
        {
          return i ;
        }
    }

  return -1 ;
}

template< class TImage, class TClassMaskImage, class TVectorImage >
int
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::GetClassIndex(unsigned int classLabel)
{
  for (unsigned int i = 0 ; i < m_UniqueClassLabels.size() ; i++)
    {
      if ( m_UniqueClassLabels[i] == classLabel )
        {
          return i ;
        }
    }

  return -1 ;
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::LoadImages()
{
  std::vector< std::string >::iterator iter = m_ImageFileNames.begin() ;

  unsigned int index = 0 ;
  while ( iter != m_ImageFileNames.end() )
    {
      m_ImageReaders.push_back(ImageReaderType::New()) ;
      m_ImageReaders[index]->SetFileName(m_ImageFileNames[index].c_str()) ;
      m_ImageReaders[index]->Update() ;
      ++iter ;
      ++index ;
    }
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::LoadClassMaskImage()
{
  // load class label mask image
  m_ClassMaskImageReader->SetFileName(m_ClassMaskImageFileName) ;
  m_ClassMaskImageReader->Update() ;

  if ( m_UseSliceFiller )
    {
      // make the size of the mask same as that of image
      // by filling and dropping slices.
      m_SliceFiller->SetInput(m_ClassMaskImageReader->GetOutput()) ;
      m_SliceFiller->SetStartingSliceNumber(m_ClassMaskImageOffset) ;
      m_SliceFiller->SetDesiredSize(m_ImageReaders[0]->
                                    GetOutput()->GetLargestPossibleRegion().GetSize()) ;
      m_SliceFiller->SetBackgroundPixelValue(m_DefaultClassLabel) ;
      m_SliceFiller->Update() ;
      
      m_ClassMaskImage = m_SliceFiller->GetOutput() ;
    }
  else
    {
      m_ClassMaskImage = m_ClassMaskImageReader->GetOutput() ;
    }
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::GenerateVectorImage()
{
  unsigned int i ;
  typename TImage::RegionType region = 
    m_ImageReaders[0]->GetOutput()->GetLargestPossibleRegion() ;

  typename TVectorImage::PixelType vi_pixel ;


  m_VectorImage->SetLargestPossibleRegion(region) ;
  m_VectorImage->SetBufferedRegion(region) ;
  m_VectorImage->Allocate() ;

  itk::ImageRegionIteratorWithIndex< TVectorImage >
    vi_iter(m_VectorImage, region) ;

  while (!vi_iter.IsAtEnd())
    {
      for ( i = 0 ; i < m_ImageFileNames.size() ; i++ )
        {
          vi_pixel[i] = 
            m_ImageReaders[i]->GetOutput()->GetPixel(vi_iter.GetIndex()) ;
        }
      vi_iter.Set(vi_pixel) ;
      ++vi_iter ;
    }
}

template< class TImage, class TClassMaskImage, class TVectorImage >
void
ValidationSampleGenerator< TImage, TClassMaskImage, TVectorImage >
::CalculateImageStatistics()
{
  unsigned int i ;
  unsigned int sampleSize = 1 ;

  typename TVectorImage::RegionType region = 
    m_VectorImage->GetLargestPossibleRegion() ;
  for ( i = 0 ; i < TImage::ImageDimension ; i++ )
    {
      sampleSize *= region.GetSize()[i] ;
    }

  MeasurementVectorType tempMins ;
  MeasurementVectorType tempMaxes ;

  typename TVectorImage::PixelType pixel ;
  m_ImageMins.Fill(itk::NumericTraits< MeasurementType >::Zero) ;
  m_ImageMaxes.Fill(itk::NumericTraits< MeasurementType >::Zero) ;
  m_ImageMeans.Fill(0.0) ;
  
  itk::ImageRegionIteratorWithIndex< TVectorImage >
    iter(m_VectorImage, region) ;

  while (!iter.IsAtEnd())
    {