int main()
{
std::cout << std::boolalpha;
constexpr unsigned sizes[]{4, 5, 3, 8, 6};
// Construction
std::cout << "Construction : " << std::endl;
std::array<char, sizes[0]> arr0{}, arr0b{{'f', 'r', 's', 'r'}}; // default
std::array<char, sizes[1]> arr1 = {'e', 'q', 'g', 't', 'e'}, arr1b({0 + 'a', 4 + 'a', 5 + 'a', 2 + 'a', 3 + 'a'}); // braced list
std::array<char, sizes[2]> arr2({'d', 's', 'a'}), arr2b = {7, 7, 'u'};
// Print elements
print(arr0, "arr0");
print(arr0b, "arr0b");
print(arr1, "arr1");
print(arr1b, "arr1b");
print(arr2, "arr2");
print(arr2b, "arr2b");
// Type aliases
std::array<char, sizes[0]>::iterator it0(arr0.begin()); // iterator
std::array<char, sizes[1]>::const_iterator cit1(arr1.begin()); // const_iterator
std::array<char, sizes[0]>::reverse_iterator rit0(--arr0.rbegin()); // iterator
std::array<char, sizes[1]>::const_reverse_iterator crit1(--arr1.crbegin()); // const_reverse_iterator
std::array<char, sizes[1]>::size_type sz1 = arr1.size(); // size_type
std::array<char, sizes[2]>::difference_type diff2 = arr2.cend() - arr2.cbegin(); // difference_type
std::array<char, sizes[2]>::value_type val2 = arr2[0]; // value_type
std::array<char, sizes[2]>::reference ref2 = arr2[1]; // reference
std::array<char, sizes[2]>::const_reference cref2 =arr2[3]; // const_reference
// Print iterators
std::cout << "it0 : " << *it0 << std::endl;
std::cout << "rit0 : " << *rit0 << std::endl;
std::cout << "cit1 : " << *cit1 << std::endl;
std::cout << "crit1 : " << *crit1 << std::endl;
std::cout << "val2 : " << val2 << std::endl;
std::cout << "ref2 : " << ref2 << std::endl;
std::cout << "cref2 : " << cref2 << std::endl;
// Size operations
std::cout << "arr1.size : " << sz1 << std::endl;
std::cout << "arr2 size : " << diff2 << std::endl; // number of elements in container
std::cout << "arr0.max_size : " << arr0.max_size() << std::endl;// max number of elements container can hold
std::cout << "arr1.max_size : " << arr1.max_size() << std::endl; // true if container empty, false otherwise
std::cout << "arr2.max_size : " << arr2.max_size() << std::endl;
// Swap
std::cout << "Assignment and swap : " << std::endl;
arr0 = arr0b; // copy assignment of object
arr1b = {'a', 'b', 'c', 'd'}; // copy assignment of braced list
arr2.swap(arr2b); // member style swap
swap(arr1, arr1b); // function style swap
// Print elements
print(arr0, "arr0");
print(arr0b, "arr0b");
print(arr1, "arr1");
print(arr1b, "arr1b");
print(arr2, "arr2");
print(arr2b, "arr2b");
// Relational operations
std::cout << "Relational operations : " << std::endl;
std::cout << "arr0 == arr0b : " << (arr0 == arr0b) << std::endl; // ==
std::cout << "arr1 != arr1b : " << (arr1 != arr1b) << std::endl; // !=
std::cout << "arr2 < arr2b : " << (arr2 < arr2b) << std::endl; // <
std::cout << "arr2 <= arr2b : " << (arr2 <= arr2b) << std::endl; // <=
std::cout << "arr1 > arr1b : " << (arr1 > arr1b) << std::endl; // >
std::cout << "arr0 >= arr0b : " << (arr0 >= arr0b) << std::endl; // >=
return 0;
}
mitk::Image::Pointer PartialVolumeAnalysisClusteringCalculator::CaculateAngularErrorImage(
mitk::Image::Pointer comp1, mitk::Image::Pointer comp2, mitk::Image::Pointer probImg) const
{
// cast input images to itk
typedef itk::Image<float, 3> ImageType;
typedef mitk::ImageToItk<ImageType> CastType;
CastType::Pointer caster = CastType::New();
caster->SetInput(comp1);
caster->Update();
ImageType::Pointer comp1Image = caster->GetOutput();
caster = CastType::New();
caster->SetInput(comp2);
caster->Update();
ImageType::Pointer comp2Image = caster->GetOutput();
caster = CastType::New();
caster->SetInput(probImg);
caster->Update();
ImageType::Pointer probImage = caster->GetOutput();
// figure out maximum probability for fiber class
float maxProb = 0;
itk::ImageRegionConstIterator<ImageType>
itprob(probImage, probImage->GetLargestPossibleRegion());
itprob.GoToBegin();
while( !itprob.IsAtEnd() )
{
maxProb = itprob.Get() > maxProb ? itprob.Get() : maxProb;
++itprob;
}
// generate a list sample of angles at positions
// where the fiber-prob is higher than .2*maxprob
typedef float MeasurementType;
const unsigned int MeasurementVectorLength = 2;
typedef itk::Vector< MeasurementType , MeasurementVectorLength >
MeasurementVectorType;
typedef itk::Statistics::ListSample< MeasurementVectorType > ListSampleType;
ListSampleType::Pointer listSample = ListSampleType::New();
listSample->SetMeasurementVectorSize( MeasurementVectorLength );
itk::ImageRegionIterator<ImageType>
it1(comp1Image, comp1Image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
it2(comp2Image, comp2Image->GetLargestPossibleRegion());
it1.GoToBegin();
it2.GoToBegin();
itprob.GoToBegin();
while( !itprob.IsAtEnd() )
{
if(itprob.Get() > 0.2 * maxProb)
{
MeasurementVectorType mv;
mv[0] = ( MeasurementType ) it1.Get();
mv[1] = ( MeasurementType ) it2.Get();
listSample->PushBack(mv);
}
++it1;
++it2;
++itprob;
}
// generate a histogram from the list sample
typedef float HistogramMeasurementType;
typedef itk::Statistics::Histogram< HistogramMeasurementType, itk::Statistics::DenseFrequencyContainer2 > HistogramType;
typedef itk::Statistics::SampleToHistogramFilter< ListSampleType, HistogramType > GeneratorType;
GeneratorType::Pointer generator = GeneratorType::New();
GeneratorType::HistogramType::SizeType size(2);
size.Fill(30);
generator->SetHistogramSize( size );
generator->SetInput( listSample );
generator->SetMarginalScale( 10.0 );
generator->Update();
// look for frequency mode in the histogram
GeneratorType::HistogramType::ConstPointer histogram = generator->GetOutput();
GeneratorType::HistogramType::ConstIterator iter = histogram->Begin();
float maxFreq = 0;
MeasurementVectorType maxValue;
maxValue.Fill(0);
while ( iter != histogram->End() )
{
if(iter.GetFrequency() > maxFreq)
{
maxFreq = iter.GetFrequency();
maxValue[0] = iter.GetMeasurementVector()[0];
maxValue[1] = iter.GetMeasurementVector()[1];
}
++iter;
}
// generate return image that contains the angular
// error of the voxels to the histogram max measurement
ImageType::Pointer returnImage = ImageType::New();
returnImage->SetSpacing( comp1Image->GetSpacing() ); // Set the image spacing
returnImage->SetOrigin( comp1Image->GetOrigin() ); // Set the image origin
returnImage->SetDirection( comp1Image->GetDirection() ); // Set the image direction
returnImage->SetRegions( comp1Image->GetLargestPossibleRegion() );
returnImage->Allocate();
itk::ImageRegionConstIterator<ImageType>
cit1(comp1Image, comp1Image->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ImageType>
cit2(comp2Image, comp2Image->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType>
itout(returnImage, returnImage->GetLargestPossibleRegion());
cit1.GoToBegin();
cit2.GoToBegin();
itout.GoToBegin();
vnl_vector<float> v(3);
v[0] = cos( maxValue[0] ) * sin( maxValue[1] );
v[1] = sin( maxValue[0] ) * sin( maxValue[1] );
v[2] = cos( maxValue[1] );
// MITK_INFO << "max vector: " << v;
while( !cit1.IsAtEnd() )
{
vnl_vector<float> v1(3);
v1[0] = cos( cit1.Get() ) * sin( cit2.Get() );
v1[1] = sin( cit1.Get() ) * sin( cit2.Get() );
v1[2] = cos( cit2.Get() );
itout.Set(fabs(angle(v,v1)));
// MITK_INFO << "ang_error " << v1 << ": " << fabs(angle(v,v1));
++cit1;
++cit2;
++itout;
}
mitk::Image::Pointer retval = mitk::Image::New();
retval->InitializeByItk(returnImage.GetPointer());
retval->SetVolume(returnImage->GetBufferPointer());
return retval;
}
