random scaler

#include "itkImage.h"
#include "itkImageFileWriter.h"
#include "itkImageFileReader.h"
#include "itkMinimumMaximumImageCalculator.h"
#include <iostream>
#include <string>
#include <stdlib.h>
#include <fstream>

using namespace std;

const unsigned int ImageDimension = 4;
const unsigned int RDImageDimension = ImageDimension-1;
typedef double  PixelType;
typedef itk::Image< PixelType, ImageDimension > ImageType;
typedef itk::Image< PixelType, RDImageDimension> RDImageType;
typedef itk::ImageFileReader< ImageType > ReaderType;
typedef itk::ImageFileWriter< ImageType > WriterType;
ofstream file;

void writetofile(PixelType min, PixelType max)
{
    file << min << " " << max << std::endl;
}

ImageType::Pointer randomscaler(ImageType::Pointer inputimage, ImageType::RegionType iterregion)
{

    typedef itk::MinimumMaximumImageCalculator <ImageType>  ImageCalculatorFilterType;
    ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New ();

    double pi = 4.0*atan(1.0);
    double U = rand()/float(RAND_MAX); double V = rand()/float(RAND_MAX);
    double X = sqrt(-2*log(U))*cos(2*pi*V);
    double Y = sqrt(-2*log(U))*sin(2*pi*V);
    double randomnumber = (Y*Y + 0.1)*(X/abs(X));

    imageCalculatorFilter->SetImage( inputimage );
    imageCalculatorFilter->Compute();

    std::cout << 25*randomnumber << std::endl;

    PixelType Omin = 25*randomnumber;
    PixelType Omax = 255-Omin;
    PixelType Imin = imageCalculatorFilter->GetMinimum();
    PixelType Imax = imageCalculatorFilter->GetMaximum();
    writetofile(Imin, Imax);

    itk::ImageRegionIterator<ImageType> imageIterator(inputimage,iterregion);
    PixelType outputPixel;
    PixelType inputPixel;

    imageIterator.GoToBegin();

    std::cout << "image iterator at end?" << imageIterator.IsAtEnd() << std::endl; //gives 1 always

    while(!imageIterator.IsAtEnd())
    {
        inputPixel = imageIterator.Get();
        outputPixel = (inputPixel-Imin)*((Omax-Omin)/(Imax-Imin))+Omin;
        imageIterator.Set(outputPixel);
        ++imageIterator;
    }

    ImageType::Pointer outputimage = inputimage;

    return outputimage;
}

int main(int argc , char *argv[])
{
    //srand(0);
    file.open("minmax.txt");

    if( argc < 3 )
    {
        std::cerr << "Usage: " << std::endl;
        std::cerr << argv[1] << " inputImageFile" << std::endl;
        std::cerr << argv[2] << " outputImageFile" << std::endl;
        return EXIT_FAILURE;
    }

    ReaderType::Pointer reader = ReaderType::New();

    reader->SetFileName(argv[1]);
    reader->Update();

    ImageType::Pointer image = reader->GetOutput();
    ImageType::RegionType region = image->GetLargestPossibleRegion();
    ImageType::SizeType size = region.GetSize();

    ImageType::IndexType volumestart;
    volumestart = image->GetLargestPossibleRegion().GetIndex();
    int nrofloops = size[ImageDimension-1];
    size[ImageDimension-1] = 0;
    region.SetSize(size);

    ImageType::Pointer scaledImage;
    vnl_vector< PixelType > Imaxvector;

    scaledImage = image;
    std::cout << "total nr of loops: " << nrofloops << std::endl;
    for(int i=0; i < nrofloops; i++)
    {
        volumestart[ImageDimension-1] = i;
        region.SetIndex(volumestart);
        scaledImage = randomscaler(scaledImage, region);
    }

    WriterType::Pointer writer = WriterType::New();

    writer->SetFileName( argv[2] );

    try
    {
        writer->SetInput( scaledImage );
        writer->Update();
    }
    catch( itk::ExceptionObject & excp )
    {
        std::cerr << excp << std::endl;
        return EXIT_FAILURE;
    }

    file.close();
    return 0;
}